标签：kong 函数名 googl 输出 优先级队列 有一个 规范 alibaba 浮点型
Date: 2019-04-20
Author: Sun
什么是自省？
自省（introspection）是一种自我检查行为。
自省是指这种能力：检查某些事物以确定它是什么、它知道什么以及它能做什么。自省向程序员提供了极大的灵活性和控制力
Python自省机制
? Python中比较常见的自省（introspection）机制(函数用法)有：help(), dir()，type(), hasattr(), isinstance()，通过这些函数，我们能够在程序运行时得知对象的类型，判断对象是否存在某个属性，访问对象的属性。
dir()
dir() 函数可能是 Python 自省机制中最著名的部分了。它返回传递给它的任何对象的属性名称经过排序的列表。如果不指定对象，则 dir() 返回当前作用域中的名称。让我们将 dir() 函数应用于 keyword 模块，并观察它揭示了什么：
>>> import math
>>> dir(math)
['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau', 'trunc']type()
? type() 函数有助于我们确定对象是字符串还是整数，或是其它类型的对象。它通过返回类型对象来做到这一点，可以将这个类型对象与 types 模块中定义的类型相比较：
>>> type(100)
<class 'int'>
>>> type([])
<class 'list'>hasattr()
? 对象拥有属性，并且 dir() 函数会返回这些属性的列表。但是，有时我们只想测试一个或多个属性是否存在。如果对象具有我们正在考虑的属性，那么通常希望只检索该属性。这个任务可以由 hasattr() 和 getattr() 函数来完成.
>>> dir(int)
>>> hasattr(int, '__doc__')
Trueisinstance()
? 可以使用 isinstance() 函数测试对象，以确定它是否是某个特定类型或定制类的实例：
>>> isinstance("python", str)
True计算机本质上是一种可以执行计算的机器，这里的计算是一种广义的“计算”，计算机上所有的处理都可以看做是计算。要计算必须的有数据，在程序中如何表示数据呢？
扩展知识：
? 运行中的程序变量保存在内存中，当执行过程中需要计算的部分放入CPU
? 访问速度：CPU > 内存 > 磁盘
在程序中，我们一般以变量表示数据，所谓变量：
变量定义：
变量名 = 值（对象）
name = '杨幂' #通过type就可以判断数据类型
age = 20
student = Student() #类的实例化对象变量名也可称之为标识符（变量名、函数名、类名、报名等统称为标识符），其命名要符合python的语法要求：
由数字、字母、下划线组成，不能以数字开头
严格区分大小写
不能是python的关键字（保留字）
获取python的保留字
import keyword
print(keyword.kwlist)
['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
好的变量命名风格应该见名知意，有意义。
小驼峰命名：
myBook yourMoney
下划线分隔：
my_book your_money模块名：
小写字母，单词之间用_分割
eg： my_test.py
包名：
和模块名一样
?
类名：
单词首字母大写，采用驼峰式命名规范。
Student
PersonList
函数&方法
函数名应该为小写，可以用下划线风格单词以增加可读性。如：myfunction，my_example_function。
函数和方法的参数
总使用“self”作为实例方法的第一个参数。总使用“cls”作为类方法的第一个参数。
全局变量名（类变量，在java中相当于static变量）：
大写字母，单词之间用_分割
SNUMBER
COLOR_WRITE
普通变量：
小写字母，单词之间用_分割
this_is_a_var
实例变量：
? 大多数情况在类中， 以_开头，其他和普通变量一样
_price
_instance_var 私有实例变量（外部访问会报错）：
以 _ _ 开头（2个下划线），其他和普通变量一样
__private_var
专有变量：
_ _ 开头， _ _结尾，一般为python的自有变量，不要以这种方式命名
__doc__
__class__
普通函数：
和普通变量一样：
get_name()
count_number()
ad_stat()
私有函数（外部访问会报错）：
? 以__开头（2个下划线），其他和普通函数一样
__get_name()
变量输出
print函数
作用：将数据显示到屏幕
用法：
显示字符串
print('hello')
显示变量
age = 20
print(age)
显示多个字符串和变量
age = 20
sex = '男'
print('俺是大傻',age,sex)
格式化显示
name = '大傻'
age = 20
#%s和%d叫占位符，替变量站了位置，显示的时候会用变量的值替换占位符
#占位符和和后面小括号里的变量一一对应
print('俺是%s,俺今年%d岁了'%(name,age))
常见的占位符
%s 字符串占位符
%d 整数的占位符
%f 浮点数的占位符
变量输入
input用于输入数据给变量
#input括号中字符串用于提示用户，不用输入
age = input('请输入你的年龄')
print(age)
删除后变量就不存在了，不能够在通过变量名进行存取了
del 变量名 #将变量名从内存中删除掉
? python中一切都是对象，python中变量保存了对象的引用，变量的好比是一个容器，容器中保存的变量所指对象的引用（地址）；变量本身是没有类型的，变量的类型是指其所指对象的类型，比如说变量是一个瓶子，盛了醋就是醋瓶，盛了酱油就是酱油瓶
num1 = 10
print(id(num1)) # 查看变量所指对象的地址
print(type(num1)) # 查看变量的类型
变量必须先定义后使用
=两边要留一个空格
程序在运行的过程中，值永远不会发生改变的量称之为常量
python没有专门的常量类型，一般约定俗成使用大写表示常量
import math
math.pi
# 圆周率
PI = 3.1415926
# 我的生日
MY_BIRTHDAY = '2008/2/29'
python解释器不解释、不执行注释
注释的优点：
注释的书写格式
单行注释，以#开始，一直到本行结束都是注释
#这是单行注释
age = 20 #这也是单行注释
多行注释
#1.使用三个单引号
'''
中间的任何内容都是注释，
可以有多行
但中间不能再有三个单引号
'''
#2.使用三个双引号
"""
中间都是注释内容
但不能出现三个双引号
"""
注意
按照作用域划分，可以分为：
#1 局部作用域
#局部变量只能在函数内部使用，外部无法引用
#局部变量的作用域从定义开始到函数体结束
def demo():
num = 20 #局部变量
print(num)
demo()
#print(num) 错误
#函数作用域
#
def outter():
x = 10 #函数作用域,从定义开始到本函数结束
def inner():
y = x #在闭包中可以引用
print(y)
return inner
pf = outter()
pf() #执行闭包
print(pf.__closure__)
#全局作用域
x = 100 #全局作用域 从定义开始到本文件结束
def demo():
print(x)
print(x)
#内建作用域，是指系统内建的函数或常量，在系统载入时加载，在所有模块中都可以直接引用
#比如说系统函数
print(max(1,2,3)) #max函数就是内建作用域 哪里都可以引用
def demo():
x = 30
y = 50
print(max(x, y))
以 L --> E --> G -->B 的规则查找，即：在局部找不到，便会去局部外的局部找（例如闭包），再找不到就会去全局找，最后到内建作用域中找。
定义在函数内部的变量拥有一个局部作用域，被称为局部变量
定义在函数外面的变量拥有一个全局作用域，被称为全局变量
total = 0 #全局变量
def sum(arg1,arg2):
total = arg1 + arg2 #局部变量
print("函数内部：",total)
return total
sum(10,20)
#print(total1)
print("函数外部：",total)
num = 1
def fun1():
print(num) #UnboundLocalError: local variable 'num' referenced before assignment
num = 123
print(num)
fun1()
不同类型的变量可以进行的运算是不同的，所以必须理解变量的类型，python中数据类型可以分为：
内置类型
内置类型分两个部分：基础类型（Number，String，Boolean，None）和 容器类型
自定义类型
基础类型
? 包含Number，String，Boolean， None
整型（int）： python3中只有int一种，可以表示整数，例如：10，-5,10000
python的int型也是4个字节，就是最大值也只是2^31；但是python 自带大数整数运算，整数不会溢出，只要内存足够
浮点型（float）： 表示带小数点的实数，有两种表示法：
小数表示： 1.9 .23
科学计数法： 用e来表示10的指数，1e2就代表了100，注意e前面必须有数值，e后面必须为整数
print(float("%.3f" % 12.45623)) #保留小数点后三位浮点数
复数（complex）：表示数学上的无理数，形如：a+bj
aComplex = 1.56 + 1.2j
bComplex = 1 - 1j
print(aComplex.real, aComplex.imag） #显示aComplex的实部和虚部
aComplex - bComplex #运算
abs(aComplex) #返回复数的模长
布尔型(bool)：表示事务的两种状态，男女、阴晴、亮暗等，它只有两个值：True，False
1 print(True==1) # 返回True
2 print(False==0) # 返回True
3 print(1 is True)
4 print(0 is False)
None：表示空对象，一般用于判断，不同于0和空字符
Null表示对象或某种数据类型（数据类型也为空，python中万物皆为对象）为空，而None表示一种一种特殊的数据类型
>>> s = '' #为s赋值一个空字符串
>>> print(s) #该行打印了一个空字符串
>>> s == None #可见,None不等于空
False
字符串（str）：在python中，可以使用字符串表示文本
字符串的表示
# 用单引号表示： 'hello'
# 用双引号表示："我用python"
# 用3个单引号表示：可以表示多行文本，例如：
'''伟大
的
祖国
'''
# 用3个双引号表示：可以表示多行文本，例如：
"""生死看淡，
不服就干"""
转义字符：有些特殊字符无法从键盘输入，可以使用转移字符表示，另外，无论是单引号、双引号还是双引号字符串，在单引号字符串中如何表示一个单引号呢，这也可以使用转义字符表示。常见的转义字符
| 转义字符 | 描述 | 转义字符 | 描述 |
|---|---|---|---|
| ‘ | 表示一个普通字符单引号 | \r | 回车 |
| " | 表示一个普通字符双引号 | \r | 回车 |
| ‘‘‘ | 一个普通的三单引号 | \\ |
一个普通的字符\ |
| """ | 一个普通的三双引号 | \a | 响铃 |
| \t | tab键 | \b | 回删一个字符 |
a = ‘My name‘s sunnychou‘
print(a)
? 输出：
? My name‘s sunnychou
? c = "My name is Peter.\tYour name is Alice."
? print(c)
? 输出：
? My name is Peter. Your name is Alice.
? 如果将上述的\t换成\n 呢？
? 如果不希望字符串转义呢？
? 在字符串前加上r或者R
? c = "My name is Peter.\tYour name is Alice."
? print(c)
? 输出：
? My name is Peter. \tYour name is Alice.
字符串编码：计算机只能识别二进制，那么字符串如何存储到计算机里呢
计算机不能直接存储字符串，但我们可以将字符编码，例如用65表示大写字符A，66表示大写字符B....等这种表示方式就是美国类的ASCII码，只能表示127个字符，但对于美国人来说已经足够了。一但能用整数表示字符，我们可以很方便的把整数用二进制表示，那么字符串也就和容易存储到计算机了。
但还有很多其他国家的语言是不能用ASCII表示的，所有ISO组织就推出了unicode码，用来表示任何一种语言的字符，unicode码也称之为万国码，通用码，可以表示任何一种语言的任何一个字符。unicdoe码有多中表示方式，例如：utf-8、utf-16、utf-32等。一般使用较多的是utf-8，utf-8是一种变长的编码，表示一个字符可能用一个字节，也可能是三个字节
中文常用编码一般用GBK编码，用2个字节表示一个汉字
chr()函数
? 是将编码转换成对应的字符
print(chr(65))
print(chr(97))
容器类型有：
? list：列表， tuple：元组， dict：字典， set：集合
List（列表）
列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。
列表的数据项不一定需要具有相同的类型
创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示：
list1 = ['Google', 'Runoob', 1997, 2000];
list2 = list([1, 3, 4, 5])
list3 = ["a", "b", "c", "d"]
—— 双向链表 有序，可变, 操作: 插入(append，insert， extend 任何位置)， 删除（remove， pop，任何位置）， 查找（L[index], 任何位置）， 遍历（列表，下标索引）
1 —》 2 —》 3 —》 4
《— 《— 《---
1、追加：names.append()
>> > names.append('e')
>> > names
['a', 'b', 'c', 'd', 'e']
2、删除：pop，remove，del
? 1）pop()
>> > names.pop()
'e'
? 如果没有指定下标，则默认会删除最后一个元素，如上述例子
>>> names.pop(2)
'c'
? 指定下标时，就会删除下标所对应的元素
? 2）remove()
>>> names.remove('e')
>>> names
['a', 'b', 'c', 'd']
? 3）del
>>> del names[4]
>>> names
['a', 'b', 'c', 'd']
?
3、查找元素所在位置：index()
>>> names.index('c')
2
4、统计元素的次数：count()
>>> names.append('d')
>>> names.count('d')
2
5、反转：reverse()
>>> names.reverse()
>>> names
['d', 'c', 'b', 'a']
6、清空：clear()
>>> names.clear()
>>> names
[]
7、插入：insert()
>>> names.insert(2,'devilf')
>>> names
['a', 'b', 'devilf', 'c', 'd']
#还有其他的插入方法：
>>> names[3] = 'lebron'
8、排序：sort()按照ascii码来进行排序
>>> names.insert(4,'&&')
>>> names
['a', 'b', 'd', 'devilf', '&&', 'lebron']
>>> names.sort()
>>> names
['&&', 'a', 'b', 'd', 'devilf', 'lebron']
9、拼接两个列表：extend()
>>> names.extend(place)
>>> names
['&&', 'a', 'b', 'd', 'devilf', 'lebron', 'beijing', 'shandong', 'usa']
10、对列表进行切片处理
1）列出所有的元素
>>> names[::]
['&&', 'a', 'b', 'd', 'devilf', 'lebron', 'beijing', 'shandong', 'usa']
2）列出最后一个元素，从中间位置开始，列出后面所有的元素
>>> names[-1]
'usa'
案例：列表操作
#1.列表组合 将多个列表拼接为一个列表 #直接使用加号 list1 = [43,65,76,6] list2 = [45,77,90,11,2,4,66] print(list1 + list2) #产生一个新列表 #2.列表重复 #直接使用乘号 列表元素重复指定遍数，产生一个新列表 print(list1 * 4) #3.成员操作 #成员运算符：in not in #运算的结果为布尔值 list3 = ["hello",False,189,"good"] print(189 in list3) #True print(180 not in list3) #True #4.列表的截取【分片，切片】 #语法：列表名[开始下标:结束下标：步长]，表示按指定步长获取从开始下标到结束下标之间的元素， # 结果为一个新的列表，步长默认是1 #注意：包头不包尾【前闭后开区间】 [开始下标,结束下标) #步长：默认是1，正数表示从左向右取，负数表示从右向左取 list1 = [10,20,30,40,50,60] print(list1[0:3]) #[10,20,30] print(list1[:3]) #[10,20,30] print(list1[:]) #[10,20,30,40,50,60] 从头取到尾 print(list1[::2]) # [10,30,50] 隔一个取一个 print(list1[3:0:-1]) #[40, 30, 20, 10] 从右向左取 print(list1[-1:-3:-1]) #[60, 50] 从右向左取 print(list1[2:]) #[30, 40, 50, 60] 从下标为2的元素开始取到末尾 print(list1[-3::-1])#[40, 30, 20, 10] 从右向左取到第一个元素
Tuple（元组）
Python 的元组与列表类似，不同之处在于元组的元素不能修改。
元组使用小括号，列表使用方括号。
—— 有序，不可变， 查找（T.index(value, start, end)), 遍历（列表，下标索引）
>>>tup1 = ('month', 'day', 1997, 2000);
>>> tup2 = (1, 2, 3, 4, 5 );
>>> tup3 = "a", "b", "c", "d"; # 不需要括号也可以
>>> type(tup3)
<class 'tuple'>
#创建空元组
tup1 = ();
注意：
? 元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用：
>> > tup1 = (50)
>> > type(tup1) # 不加逗号，类型为整型
<class 'int'>
>> > tup1 = (50,)
>> > type(tup1) # 加上逗号，类型为元组
<class 'tuple'>
? 元组与字符串类似，下标索引从0开始，可以进行截取，组合等。
? 元组可以使用下标索引来访问元组中的值，如下实例:
tup1 = ('Google', 'baidu', 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7)
print("tup1[0]: ", tup1[0])
print("tup2[1:5]: ", tup2[1:5])
修改元组
元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，如下实例:
tup1 = (12, 34.56);
tup2 = ('abc', 'xyz')
# 以下修改元组元素操作是非法的。
# tup1[0] = 100
# 创建一个新的元组
tup3 = tup1 + tup2;
print(tup3)
? 元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组，如下实例:
tuple = ('Google', 'baidu', 1997, 2000)
print(tuple)
del tuple;
print("删除后的元组 tuple : ")
print(tuple)
? 以上实例元组被删除后，输出变量会有异常信息，输出如下所示：
删除后的元组 tuple :
Traceback (most recent call last):
File "test.py", line 8, in <module>
print (tuple)
NameError: name 'tuple' is not defined
enumerate() 方法
seasons = ['Spring', 'Summer', 'Autumn', 'Winter']
list(enumerate(seasons))
list(enumerate(seasons, start=1)) # 下标从 1 开始
>>>seq = ['one', 'two', 'three']
>>> for i, element in enumerate(seq):
... print(i, element)
Dictionary（字典）
字典是一种可变容器模型，且可存储任意类型对象。
? 字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中 ,格式如下所示：
d = {key1 : value1, key2 : value2 }
? 键必须是唯一的，但值则不必。
? 值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。
一个简单的字典实例：
dict = {'A': '11111', 'B': '2222', 'C': '3333'}
— — key-value键值对。
? 创建（1. mdict={‘key‘:value}, 2.mdict=dict(key=value)）
? 插入：mdict[key] = value 获取：key获取value数据（get， pop）
? 查找：mdict[key], mdict.get(key), 遍历（安装mdict.keys（）遍历key，由mdict[key]获取value）
? 把相应的键放入到方括号中，如下实例:
dict = {'Name': 'Andy', 'Age': 37, 'Class': 'Hongkong'}
print("dict['Name']: ", dict['Name'])
print("dict['Age']: ", dict['Age'])
? 如果用字典里没有的键访问数据，会输出没有key错误：KeyError
修改字典
向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对
dict = {'Name': 'Andy', 'Age': 37, 'Class': 'Hongkong'}
dict['Age'] = 48; # 更新 Age
dict['School'] = "清华大学" # 添加信息
print("dict['Age']: ", dict['Age'])
print("dict['School']: ", dict['School'])
删除字典元素
能删单一的元素也能清空字典，清空只需一项操作。
? 显示删除一个字典用del命令
del dict['Name'] # 删除键 'Name'
dict.clear() # 清空字典
del dict # 删除字典
print("dict['Age']: ", dict['Age'])
print("dict['School']: ", dict['School'])
? 这会引发一个异常，因为用执行 del 操作后字典不再存在
字典键特性
? 字典值可以是任何的 python 对象，既可以是标准的对象，也可以是用户定义的，但键不行
? 1）不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住
? 2）键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行
eg:
dict = {['Name']: 'Andy', 'Age': 37, 'Class': 'Hongkong'}
print("dict['Name']: ", dict['Name'])
此时，就会出异常，TypeError: unhashable type: ‘list‘ 错误
其他使用方法
len(dict) 计算字典元素个数，即键的总数
str(dict) 输出字典，以可打印的字符串表示。
Set （集合）
集合（set）是一个无序的不重复元素序列
可以使用大括号 { } 或者 set() 函数创建集合
集合对象还支持union(联合), intersection(交), difference(差)等操作。
作用：（1）去重 （2）运算：交集（intersection），并集(union)
>>>basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> print(basket) # 这里演示的是去重功能
{'orange', 'banana', 'pear', 'apple'}
>>> 'orange' in basket # 快速判断元素是否在集合内
True
>>> 'crabgrass' in basket
False
# 下面展示两个集合间的运算.
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a
{'a', 'r', 'b', 'c', 'd'}
>>> a - b # 集合a中包含而集合b中不包含的元素
{'r', 'd', 'b'}
>>> a | b # 集合a或b中包含的所有元素
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b # 集合a和b中都包含了的元素
{'a', 'c'}
>>> a ^ b # 不同时包含于a和b的元素
{'r', 'd', 'b', 'm', 'z', 'l'}
同样集合支持集合推导式
>>>a = {x for x in 'abcbde' if x not in 'abc'}
>>> a
{'d', 'e'}
添加元素
s.add( x )
? 将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作。
>>>thisset = set(("baidu", "Alibaba", "Tenxun"))
>>> thisset.add("Facebook")
>>> print(thisset)
{'Tenxun', 'Facebook', 'baidu', 'Alibaba'}
? 还有一个方法，也可以添加元素，且参数可以是列表，元组，字典等
? 语法格式如下：
s.update( x ) # x 可以有多个，用逗号分开。
>>>thisset = set(("Google", "baidu", "Taobao"))
>>> thisset.update({1,3})
>>> print(thisset)
{1, 3, 'Google', 'Taobao', 'baidu'}
>>> thisset.update([1,4],[5,6])
>>> print(thisset)
{1, 3, 4, 5, 6, 'Google', 'Taobao', 'baidu'}
移除元素
s.remove( x )
? 将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误。
>>>thisset = set(("Google", "Runoob", "Taobao"))
>>>thisset.remove("Taobao")
>>> print(thisset)
{'Google', 'Runoob'}
>>>thisset.remove("Facebook") # 不存在会发生错误
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'Facebook'
? 此外还有一个方法也是移除集合中的元素，且如果元素不存在，不会发生错误，如下discard函数
s.discard( x )
清空集合
s.clear()
判断元素 x 是否在集合
x in s
? 判断元素 x 是否在集合 s 中，存在返回 True，不存在返回 False。
>>>thisset = set(("Google", "Runoob", "Taobao"))
>>> "Runoob" in thisset
True
>>> "Facebook" in thisset
False
| 方法 | 描述 |
|---|---|
| add() | 为集合添加元素 |
| clear() | 移除集合中的所有元素 |
| copy() | 拷贝一个集合 |
| difference() | 返回多个集合的差集 |
| difference_update() | 移除集合中的元素，该元素在指定的集合也存在。 |
| discard() | 删除集合中指定的元素 |
| intersection() | 返回集合的交集 |
| intersection_update() | 删除集合中的元素，该元素在指定的集合中不存在。 |
| isdisjoint() | 判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。 |
| issubset() | 判断指定集合是否为该方法参数集合的子集。 |
| issuperset() | 判断该方法的参数集合是否为指定集合的子集 |
| pop() | 随机移除元素 |
| remove() | 移除指定元素 |
| symmetric_difference() | 返回两个集合中不重复的元素集合。 |
| symmetric_difference_update() | 移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。 |
| union() | 返回两个集合的并集 |
| update() | 给集合添加元素 |
Queue (队列)
? Queue是python标准库中的线程安全的队列（FIFO）实现,提供了一个适用于多线程编程的先进先出的数据结构，即队列，用来在生产者和消费者线程之间的信息传递
— 存储先进先出的对象
? 创建方式：mq = queue.Queue(maxsize=0)
? 插入：put， put_nowait, 取数据：get, get_nowait
from queue import Queue #LILO队列
q = Queue() #创建队列对象
q.put(0) #在队列尾部插入元素
q.put(1)
q.put(2)
print('LILO队列',q.queue) #查看队列中的所有元素
print(q.get()) #返回并删除队列头部元素
print(q.queue)
from queue import LifoQueue #LIFO队列
lifoQueue = LifoQueue()
lifoQueue.put(1)
lifoQueue.put(2)
lifoQueue.put(3)
print('LIFO队列',lifoQueue.queue)
lifoQueue.get() #返回并删除队列尾部元素
lifoQueue.get()
print(lifoQueue.queue)
from queue import PriorityQueue #优先队列
priorityQueue = PriorityQueue() #创建优先队列对象
priorityQueue.put(3) #插入元素
priorityQueue.put(78) #插入元素
priorityQueue.put(100) #插入元素
print(priorityQueue.queue) #查看优先级队列中的所有元素
priorityQueue.put(1) #插入元素
priorityQueue.put(2) #插入元素
print('优先级队列:',priorityQueue.queue) #查看优先级队列中的所有元素
priorityQueue.get() #返回并删除优先级最低的元素
print('删除后剩余元素',priorityQueue.queue)
priorityQueue.get() #返回并删除优先级最低的元素
print('删除后剩余元素',priorityQueue.queue) #删除后剩余元素
priorityQueue.get() #返回并删除优先级最低的元素
print('删除后剩余元素',priorityQueue.queue) #删除后剩余元素
priorityQueue.get() #返回并删除优先级最低的元素
print('删除后剩余元素',priorityQueue.queue) #删除后剩余元素
priorityQueue.get() #返回并删除优先级最低的元素
print('全部被删除后:',priorityQueue.queue) #查看优先级队列中的所有元素
from collections import deque #双端队列
dequeQueue = deque(['Eric','John','Smith'])
print(dequeQueue)
dequeQueue.append('Tom') #在右侧插入新元素
dequeQueue.appendleft('Terry') #在左侧插入新元素
print(dequeQueue)
dequeQueue.rotate(2) #循环右移2次
print('循环右移2次后的队列',dequeQueue)
dequeQueue.popleft() #返回并删除队列最左端元素
print('删除最左端元素后的队列：',dequeQueue)
dequeQueue.pop() #返回并删除队列最右端元素
print('删除最右端元素后的队列：',dequeQueue)
Collections
? Counter， defaultdict， deque， namedtuple， OrderedDict
? 见下节《2-Collections库使用》
自定义类型：类
类是一种高级抽象,就是一种高级的数据类型,是对象的蓝图,就是用来定义你要用的对象的属性和行为的
class MyClass:
"""一个简单的类实例"""
i = 12345
def f(self):
return 'hello world'
# 实例化类
x = MyClass()
# 访问类的属性和方法
print("MyClass 类的属性 i 为：", x.i)
print("MyClass 类的方法 f 输出为：", x.f())
标签：kong 函数名 googl 输出 优先级队列 有一个 规范 alibaba 浮点型
原文地址：https://www.cnblogs.com/sunBinary/p/10929856.html
