创建列表的方式
list= [XX,XX]
或
list1 = list（）使用list方法，将字符串或元祖创建为列表
列表名[其实位置：结束位置] 取列表中的特定元素
>>> name
['aa', 'cc', 'dd', 33, 4, 5, 6, 8]
>>> name[1:3]
['cc', 'dd']
如果从后向前取，则从-1开始
>>> name
['aa', 'cc', 'dd', 33, 4, 5, 6, 8]
>>> name[-5:-3]
[33, 4]
从一个位置取到列表结束
>>> name
['aa', 'cc', 'dd', 33, 4, 5, 6, 8]
>>> name[3:]
[33, 4, 5, 6, 8]
从开始取到一个位置
>>> name
['aa', 'cc', 'dd', 33, 4, 5, 6, 8]
>>> name[:3]
['aa', 'cc', 'dd']
默认情况下，每次取值步长为1，那么如果要改变步长，也就是如果要隔1个取一个，则
>>> name
['aa', 'cc', 'dd', 33, 4, 5, 6, 8]
>>> name[::2]
['aa', 'dd', 4, 6]
上面步长为2，则隔一个取一个，如果为3则隔两个取一个
列表名.copy //复制列表，但是如果是多维列表，则仅copy外层的列表，在层列表中内层列表的位置仅复制内存地址。因此如果新复制的列表中内层列表值变化，则新旧的表的内层列表值都会变化。
>>> name = [1,2,3,4,5,6]
>>> name1 = name.copy()
>>> name1
[1, 2, 3, 4, 5, 6]
>>> import copy
>>> name1 = name.copy()
>>> name
['aa', 'cc', 'dd', 33, 4, 5, 6, 8]
>>> name1.insert(1,["fs","dg",448])
>>>
>>>
>>> name
['aa', 'cc', 'dd', 33, 4, 5, 6, 8]
>>> name1
['aa', ['fs', 'dg', 448], 'cc', 'dd', 33, 4, 5, 6, 8]
>>> name2 = copy.deepcopy(name1)
>>> name2
['aa', ['fs', 'dg', 448], 'cc', 'dd', 33, 4, 5, 6, 8]
>>>
>>>
>>>
>>> name2[1][1]= "ss"
>>> name1
['aa', ['fs', 'dg', 448], 'cc', 'dd', 33, 4, 5, 6, 8]
>>> name2
['aa', ['fs', 'ss', 448], 'cc', 'dd', 33, 4, 5, 6, 8]
>>>
如果要将内层列表也复制，则应该是使用标准库copy
import copy
name1 = copy.deepcopy(name),这样name1的值就会完全复制name列表，改变name1不会影响name列表
列表名.reverse （）翻转列表内的元素，例如原来是 [1,2,3,4]，翻转后变成[4,3,2,1]，会改变源列表
>>> name
[6, 5, 4, 3, 2, 1]
>>> name.reverse()
>>> name
[1, 2, 3, 4, 5, 6]
列表名.remove(列表中的元素） ，删除列表中出现的第一个元素内容，会改变源列表
>>> name
['aa', 'cc', 'dd', 33, 4, 8, 5, 6, 8]
>>> name.remove(8)
>>> name
['aa', 'cc', 'dd', 33, 4, 5, 6, 8]
列表名.insert（插入位置，插入内容），在插入位置中插入内容，会改变源列表
>>> name
[1, 2, 4, 5, 6]
>>> name.insert(2,5)
>>> name
[1, 2, 5, 4, 5, 6]
列表名.append（插入内容），在最后追加插入内容，会改变源列表
>>> name
['aa', 'cc', 'dd', 33, 4, 8, 5, 6]
>>> name.append(8)
>>> name
['aa', 'cc', 'dd', 33, 4, 8, 5, 6, 8]
列表名.pop（列表位置），删除列表为止的元素，按角标删除，并显示删除的内容，会改变源列表
>>> name1
['aa', ['fs', 'dg', 448], 'cc', 'dd', 33, 4, 5, 6, 8]
>>> name1.pop(1)
['fs', 'dg', 448]
>>> name1
['aa', 'cc', 'dd', 33, 4, 5, 6, 8]
列表名.extend（另一个列表名），将另一个列表追加到当前列表的后面，会改变源列表
>>> list1
[3, 4, 5, 6]
>>> list2
[88, 99, 10]
>>> list2.extend(list1)
>>> list2
[88, 99, 10, 3, 4, 5, 6]
列表名.index（内容），查询内容在列表中出现的第一个位置，所有此类查询都只是以元素查询，即如果查询9则99 999都不会被查到，也就是并不能查到一个元素中包含9的数量，而是精确查找9
>>> list1
[3, 4, 5, 6]
>>> print(list1.index(3))
0
>>>
列表名.sort（），将当前列表排序，在python 2中可以将字符串和数字一起排列，但是在python3中则不能一起排列，会改变源列表
>>> list3
['aa', 'bb', 'cc']
>>> list3[1]="dd"
>>> list3.sort()
>>> list3
['aa', 'cc', 'dd']
>>> list3
['aa', 'cc', 'dd', 44]
>>> list3.sort()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unorderable types: int() < str()
列表名.count（内容），查询内容在列表中出现的次数，精确匹配
>>> list4
['aa', 'cc', 4, 5, 4, 66, 99]
>>> list4.count(4)
2
>>> list4.count(6)
0
del 列表[1] 删除列表中1角标的元素，del可以用来删除所有的内容，包括变量，列表，元素
判断 内容是否在列表中
if "F0B2.E58F.F162" in MACLIST:
print("True")
else:
print("false")
元组的定义
元组是指不能被更改的列表，一旦列表被定义为元组，则元组内的元素将不能被修改
元组的定义方法 list = （），列表使用[]定义，元组使用（）定义
在元组的操作中，只有index和count可用
将元组列表话，元组名.list()
字符串操作
strip（），用来去掉字符串中的字符，默认为空格，如果要去掉特别的字符在括号中表明，会改变源字符串
>>> name
'liubo]'
>>> name1 = name.strip("]")
>>> name1
'liubo'
split（），分离将字符串按照具体的符号分离为列表，具体符号在括号中定义，不会改变源字符串
>>> maclist
'F0B2.E58F.F162,F0B2.E58F.88C9,F0B2.E58F.EE46,F0B2.E58F.F1A6,F0B2.E58F.EC50,F0B2.E58F.F1A7,F0B2.E58F.F17E,F0B2.E58F.F089,F0B2.E58F.F026,F0B2.F58F.F15D,F0B2.F58F.F056,F0B2.E58F.EE1E,F0B2.F58F.EFFF,F0B2.E58F.F17A,F0B2.E58F.F16C,F0B2.E58F.ECD4,F0B2.E58F.F19C,F0B2.E58F.F170,F0B2.E58F.ECC5,F0B2.E58F.EC5D,F0B2.E58F.ECC3,F0B2.E58F.8792,F0B2.E58F.F198,F0B2.E58F.ECDA,F0B2.E58F.F0EA,F0B2.E58F.F147,F0B2.E58F.F195,F0B2.E58F.F08C,F0B2.E58F.F19B,F0B2.E58F.F06A'
>>> MACLIST = maclist.split(",")
>>> MACLIST
['F0B2.E58F.F162', 'F0B2.E58F.88C9', 'F0B2.E58F.EE46', 'F0B2.E58F.F1A6', 'F0B2.E58F.EC50', 'F0B2.E58F.F1A7', 'F0B2.E58F.F17E', 'F0B2.E58F.F089', 'F0B2.E58F.F026', 'F0B2.F58F.F15D', 'F0B2.F58F.F056', 'F0B2.E58F.EE1E', 'F0B2.F58F.EFFF', 'F0B2.E58F.F17A', 'F0B2.E58F.F16C', 'F0B2.E58F.ECD4', 'F0B2.E58F.F19C', 'F0B2.E58F.F170', 'F0B2.E58F.ECC5', 'F0B2.E58F.EC5D', 'F0B2.E58F.ECC3', 'F0B2.E58F.8792', 'F0B2.E58F.F198', 'F0B2.E58F.ECDA', 'F0B2.E58F.F0EA', 'F0B2.E58F.F147', 'F0B2.E58F.F195', 'F0B2.E58F.F08C', 'F0B2.E58F.F19B', 'F0B2.E58F.F06A']
"".join()，合并列表为字符串，""中定义了合并后原来列表元素的分隔符，要合并的列表名写在括号内，不会改变源列表
>>> MACLIST
['F0B2.E58F.F162', 'F0B2.E58F.88C9', 'F0B2.E58F.EE46', 'F0B2.E58F.F1A6', 'F0B2.E58F.EC50', 'F0B2.E58F.F1A7', 'F0B2.E58F.F17E', 'F0B2.E58F.F089', 'F0B2.E58F.F026', 'F0B2.F58F.F15D', 'F0B2.F58F.F056', 'F0B2.E58F.EE1E', 'F0B2.F58F.EFFF', 'F0B2.E58F.F17A', 'F0B2.E58F.F16C', 'F0B2.E58F.ECD4', 'F0B2.E58F.F19C', 'F0B2.E58F.F170', 'F0B2.E58F.ECC5', 'F0B2.E58F.EC5D', 'F0B2.E58F.ECC3', 'F0B2.E58F.8792', 'F0B2.E58F.F198', 'F0B2.E58F.ECDA', 'F0B2.E58F.F0EA', 'F0B2.E58F.F147', 'F0B2.E58F.F195', 'F0B2.E58F.F08C', 'F0B2.E58F.F19B', 'F0B2.E58F.F06A']
>>> newlist = "|".join(MACLIST)
>>> newlist
'F0B2.E58F.F162|F0B2.E58F.88C9|F0B2.E58F.EE46|F0B2.E58F.F1A6|F0B2.E58F.EC50|F0B2.E58F.F1A7|F0B2.E58F.F17E|F0B2.E58F.F089|F0B2.E58F.F026|F0B2.F58F.F15D|F0B2.F58F.F056|F0B2.E58F.EE1E|F0B2.F58F.EFFF|F0B2.E58F.F17A|F0B2.E58F.F16C|F0B2.E58F.ECD4|F0B2.E58F.F19C|F0B2.E58F.F170|F0B2.E58F.ECC5|F0B2.E58F.EC5D|F0B2.E58F.ECC3|F0B2.E58F.8792|F0B2.E58F.F198|F0B2.E58F.ECDA|F0B2.E58F.F0EA|F0B2.E58F.F147|F0B2.E58F.F195|F0B2.E58F.F08C|F0B2.E58F.F19B|F0B2.E58F.F06A'
判断字符串中是否存在特定字符
print（“” in name） 判断那么字符串中是否存在空格，“”代表空格，如果需要查其他的在“”内输入
字符串名.capitalize（） 字符串首字母大写
字符串名.format（） 格式化输出
>>> msg = "hello,{name} your age is {age}?"
>>> print(msg.format(name = "liubo",age=30))
hello,liubo your age is 30?
>>> msg2 = "hahahah{0},dddd{1}"
>>> print(msg2.format("aaa",333))
hahahahaaa,dddd333
第二种方法中的序号必须按顺序 不能跳
字符串切片，同列表切片
字符串名.center()，将字符串取中，两边用具体字符填充，其中40代表总填充的值，字符串将在40中间的位置也就是两边各20的位置显示
>>> name = "liubo"
>>> name.center(40,"-")
'-----------------liubo------------------'
字符串名.find（） 查找字符串中是否有具体的值，值填入括号中，并将值所在的第一个位置的索引显示出来，如果没有则为-1
>>> name = "iulbo"
>>> name.find("l")
2
>>> name.find("x")
-1
字符串名.isdigit() 判断字符串是否为数字
age=input("yourage:")
if age.isdigit():
age = int(age)
else:
print("invalid data type")
同理，isalnum()判断字符串中是否包含阿拉伯数字
字符串名.endswith("xx") 判断字符串是否以xx结尾
字符串名.startswith("xx") 判断字符串是否以xx开始
字符串名.upper()，字符串改大写
字符串名.lower()，字符串改小写
|
操作符 |
描述符 |
例子 |
|
+ |
加法 - 对操作符的两侧增加值 |
a + b = 30 |
|
- |
减法 - 减去从左侧操作数右侧操作数 |
a - b = -10 |
|
* |
乘法 - 相乘的运算符两侧的值 |
a * b = 200 |
|
/ |
除 - 由右侧操作数除以左侧操作数 |
b / a = 2 |
|
% |
模 - 由右侧操作数和余返回除以左侧操作数 |
b % a = 0 |
|
** |
指数- 执行对操作指数（幂）的计算 |
a**b = 10 的幂 20 |
|
// |
地板除 - 操作数的除法，其中结果是将小数点后的位数被除去的商。 |
9//2 = 4 而 9.0//2.0 = 4.0 |
源文档 <http://www.yiibai.com/python/python_basic_operators.html>
|
运算符 |
描述 |
示例 |
|
== |
检查，两个操作数的值是否相等，如果是则条件变为真。 |
(a == b) 不为 true. |
|
!= |
检查两个操作数的值是否相等，如果值不相等，则条件变为真。 |
(a != b) 为 true. |
|
<> |
检查两个操作数的值是否相等，如果值不相等，则条件变为真。 |
(a <> b) 为 true。这个类似于 != 运算符 |
|
> |
检查左操作数的值是否大于右操作数的值，如果是，则条件成立。 |
(a > b) 不为 true. |
|
< |
检查左操作数的值是否小于右操作数的值，如果是，则条件成立。 |
(a < b) 为 true. |
|
>= |
检查左操作数的值是否大于或等于右操作数的值，如果是，则条件成立。 |
(a >= b) 不为 true. |
|
<= |
检查左操作数的值是否小于或等于右操作数的值，如果是，则条件成立。 |
(a <= b) 为 true. |
源文档 <http://www.yiibai.com/python/python_basic_operators.html>
|
运算符 |
描述 |
示例 |
|
= |
简单的赋值运算符，赋值从右侧操作数左侧操作数 |
c = a + b将指定的值 a + b 到 c |
|
+= |
加法AND赋值操作符，它增加了右操作数左操作数和结果赋给左操作数 |
c += a 相当于 c = c + a |
|
-= |
减AND赋值操作符，它减去右边的操作数从左边操作数，并将结果赋给左操作数 |
c -= a 相当于 c = c - a |
|
*= |
乘法AND赋值操作符，它乘以右边的操作数与左操作数，并将结果赋给左操作数 |
c *= a 相当于 c = c * a |
|
/= |
除法AND赋值操作符，它把左操作数与正确的操作数，并将结果赋给左操作数 |
c /= a 相当于= c / a |
|
%= |
模量AND赋值操作符，它需要使用两个操作数的模量和分配结果左操作数 |
c %= a is equivalent to c = c % a |
|
**= |
指数AND赋值运算符，执行指数（功率）计算操作符和赋值给左操作数 |
c **= a 相当于 c = c ** a |
|
//= |
地板除，并分配一个值，执行地板除对操作和赋值给左操作数 |
c //= a 相当于 c = c // a |
源文档 <http://www.yiibai.com/python/python_basic_operators.html>
|
操作符 |
描述 |
示例 |
|
& |
二进制和复制操作了一下，结果，如果它存在于两个操作数。 |
(a & b) = 12 即 0000 1100 |
|
| |
二进制或复制操作了一个比特，如果它存在一个操作数中。 |
(a | b) = 61 即 0011 1101 |
|
^ |
二进制异或运算符的副本，如果它被设置在一个操作数而不是两个比特。 |
(a ^ b) = 49 即 0011 0001 |
|
~ |
二进制的补运算符是一元的，并有“翻转”位的效果。 |
(~a ) = -61 即 1100 0011以2的补码形式由于带符号二进制数。 |
|
<< |
二进位向左移位运算符。左操作数的值左移由右操作数指定的位数。 |
a << 2 = 240 即 1111 0000 |
|
>> |
二进位向右移位运算符。左操作数的值是由右操作数指定的位数向右移动。 |
a >> 2 = 15 即 0000 1111 |
|
运算符 |
描述 |
示例 |
|
and |
所谓逻辑与运算符。如果两个操作数都是真的，那么则条件成立。 |
(a and b) 为 true. |
|
or |
所谓逻辑OR运算符。如果有两个操作数都是非零然后再条件变为真。 |
(a or b) 为 true. |
|
not |
所谓逻辑非运算符。用于反转操作数的逻辑状态。如果一个条件为真，则逻辑非运算符将返回false。 |
not(a and b) 为 false. |
源文档 <http://www.yiibai.com/python/python_basic_operators.html>
|
操作符 |
描述 |
示例 |
|
in |
计算结果为true，如果它在指定找到变量的顺序，否则false。 |
x在y中，在这里产生一个1，如果x是序列y的成员。 |
|
not in |
计算结果为true，如果它不找到在指定的变量顺序，否则为false。 |
x不在y中，这里产生结果不为1，如果x不是序列y的成员。 |
源文档 <http://www.yiibai.com/python/python_basic_operators.html>
|
运算符 |
描述 |
例子 |
|
is |
计算结果为true，如果操作符两侧的变量指向相同的对象，否则为false。 |
x是y，这里结果是1，如果id（x）的值为id（y）。 a = "sss" type(a) is str true |
|
is not |
计算结果为false，如果两侧的变量操作符指向相同的对象，否则为true。 |
x不为y，这里结果不是1，当id（x）不等于id（y）。 |
源文档 <http://www.yiibai.com/python/python_basic_operators.html>
Python运算符优先级
下表列出了所有运算符从最高优先级到最低。
[ 查看示例 ]
|
运算符 |
描述 |
|
** |
幂（提高到指数） |
|
~ + - |
补码，一元加号和减号（方法名的最后两个+@和 - @） |
|
* / % // |
乘，除，取模和地板除 |
|
+ - |
加法和减法 |
|
>> << |
左，右按位转移 |
|
& |
位'AND' |
|
^ | |
按位异'或`'和定期`或' |
|
<= < > >= |
比较运算符 |
|
<> == != |
等式运算符 |
|
= %= /= //= -= += *= **= |
赋值运算符 |
|
is is not |
标识运算符 |
|
in not in |
成员运算符 |
|
not or and |
逻辑运算符 |
源文档 <http://www.yiibai.com/python/python_basic_operators.html>
二进制 左移 > > 开根
右移，2次方
循环
while true： 为真就循环，为了避免出现死循环，应该设置一个退出条件
例如
count = 0
while true：
count +=1
print（“test”）
if count == 100 ：
print（“end”）
break
当需要在循环中的一个区间单独设置，也就是终端当前循环，直接开始下一个循环，使用continue
continue，终端当前循环，继续下一个循环
下例子中当count在50到60之间时，执行continue，因此不会打印test
count = 0
while true：
count +=1
if count > 50 and count < 60: /
continue
print（“test”）
if count == 100 ：
print（“end”）
break
break，直接终止循环
字典
字典格式的定义使用{}，列表为[]，元组是（）
字典中可以嵌套字典
字典的第一个字段是key字段，字典会基于key字段去重复
下例中的1,2就是第一个字段
>>> dict_db = {
... 1:{
... "liubo":{
... "age":30,
... "addr":"beijing"
... },
... "liubo2":{
... "age":33,
... "addr":"ganshu"
... },
... },
... 2:{
... "zhangsan":{
... "age":20,
... "addr":"guangdong"
...
... }
... }
...
... }
>>>
>>> print(dict_db)
{1: {'liubo': {'addr': 'beijing', 'age': 30}, 'liubo2': {'addr': 'ganshu', 'age': 33}}, 2: {'zhangsan': {'addr': 'guangdong', 'age': 20}}}
字典的元素的定义格式是key：value的模式，例如上面的“age”：30
下列操作字典名后面[]内的层级依据实际情况
字典名[字典key字段的值] 取字典中的值
>>> dict_db[2] //[2]是字典中的key字段的值，上例中是1 和2 本例取2
{'zhangsan': {'addr': 'guangdong', 'age': 20}}
字典名[字典key字段的值] [内部字段名] = XXX 改变字典中特定字段内特别变量的值
>>> dict_db[2]["zhangsan"]["addr"] = "USA"
>>> dict_db[2]["zhangsan"]
{'addr': 'USA', 'age': 20}
字典名[字典key字段的值] [新的内部字段名] = XXX 在字典中增加字段
>>> dict_db[2]["zhangsan"]["QQ"]=2222222
>>> dict_db[2]
{'zhangsan': {'addr': 'USA', 'QQ': 2222222, 'age': 20}}
>>>
del 字典名[字典key字段的值] [指定的字段名]
或
字典名[字典key字段的值].pop（“字段名”）删除特定字段
>>> del dict_db[2]["zhangsan"]["QQ"]
>>> dict_db[2]
{'zhangsan': {'addr': 'USA', 'age': 20}}
或
>>> dict_db[2]
{'zhangsan': {'addr': 'USA', 'age': 20}}
>>> dict_db[2]["zhangsan"].pop("age")
20
>>> dict_db[2]
{'zhangsan': {'addr': 'USA'}}
>>>
字典.copy()，复制 同列表为浅copy
>>> id_db = dict_db[2].copy() //将dict_db第二个子字典复制给id_db
>>> id_db
{'zhangsan': {'addr': 'USA'}}
>>>
>>>
>>> dict_db[2]["zhangsan"]["addr"] = "UK" //修改dict_db中的值
>>> id_db
{'zhangsan': {'addr': 'UK'}} //id_db也被修改了
字典.get()，获取 get方法和直接赋值是一样的，但是使用get方法如果获取一个不存在的值会返回NONE，但是直接赋值则会报错
>>> v = id_db[3] //直接赋值造成报错，中断程序
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 3
>>> v = id_db.get(3) 使用get方法不会造成程序中断
>>> print(v)
None
旧字典.update（“新字典”） 使用新字典的内容去更新旧字典，如果旧字典中有对应的key则用新字典中的key覆盖，如果么有则将新字典中的key新增在旧字典中
>>> dict_db //旧字典
{1: {'liubo': {'addr': 'beijing', 'age': 30}, 'liwei': {'addr': 'ganshu', 'age': 33}}, 2: {'zhangsan': {'addr': 'UK'}}}
>>>
>>>
>>> new = { 2:{"name":"lisi","age":4444,"ip":"aaa"},5:{"test":334}
... }
>>> new //新字典
{2: {'ip': 'aaa', 'age': 4444, 'name': 'lisi'}, 5: {'test': 334}}
>>> dict_db.update(new)
>>> dict_db
{1: {'liubo': {'addr': 'beijing', 'age': 30}, 'liubo2': {'addr': 'ganshu', 'age': 33}}, 2: {'ip': 'aaa', 'age': 4444, 'name': 'lisi'}, 5: {'test': 334}}
>>>
print（字典.items（）），将字典转化为列表或元祖，这个动作非常耗时，因此尽量不要使用
>>> print(id_db.items())
dict_items([('zhangsan', {'addr': 'UK'})])
print（字典.values（）），打印字典中所有的值
>>> print(dict_db)
{1: {'liubo': {'addr': 'beijing', 'age': 30}, 'liubo2': {'addr': 'ganshu', 'age': 33}}, 2: {'ip': 'aaa', 'age': 4444, 'name': 'lisi'}, 5: {'test': 334}}
>>> print(dict_db.values())
dict_values([{'liubo': {'addr': 'beijing', 'age': 30}, 'liwei': {'addr': 'ganshu', 'age': 33}}, {'ip': 'aaa', 'age': 4444, 'name': 'lisi'}, {'test': 334}]) //没有1和2了
print(字典.keys())，打印字典中所有的key
>>> print(dict_db.keys())
dict_keys([1, 2, 5])
字典.has_key（特定的key） 在python 2.0中的方法，判断字典中是否存在特定的key
特定的key in 字典 在python 3.0中，判断字典中是否存在特定的key
>>> 1 in id_db
False
>>> 1 in dict_db
True
print(字典.setdefault(key，值)) 如果key在这个字典中存在，则返回值，如果不存在则在字典中追加这个key，并指定默认值，如果没有指定则为None
>>> id_db
{222: {'name': 'zhangsan', 'age': 33}, 1111: {'name': 'liubo', 'age': 30}}
>>> print(id_db.setdefault(111))
None
>>> id_db
{111: None, 222: {'name': 'zhangsan', 'age': 33}, 1111: {'name': 'liubo', 'age': 30}}
>>> print(id_db.setdefault(222))
{'name': 'zhangsan', 'age': 33}
>>> print(id_db.setdefault(2222,"test"))
test
>>> id_db
{111: None, 2222: 'test', 222: {'name': 'zhangsan', 'age': 33}, 1111: {'name': 'liubo', 'age': 30}}
print(id_db.fromkeys([字典的key]，默认值）） ，按照字典的key列表的接口输入为字典的key，key的值为默认值，不改变元字典
>>> id_db
{111: None, 2222: 'test', 222: {'name': 'zhangsan', 'age': 33}, 1111: {'name': 'liubo', 'age': 30}}
>>> print(id_db.fromkeys([111,333,555],"aaaa"))
{555: 'aaaa', 333: 'aaaa', 111: 'aaaa'}
>>> id_db
{111: None, 2222: 'test', 222: {'name': 'zhangsan', 'age': 33}, 1111: {'name': 'liubo', 'age': 30}}
>>>
print(id_db.popitem()) 随机删除字典中的key
遍历字典
>>> for x in id_db:
... print(x,id_db[x])
...
111 None
2222 test
222 {'name': 'zhangsan', 'age': 33}
1111 {'name': 'liubo', 'age': 30}
遍历字典时输出序列号，枚举函数
使用字典、元祖或列表
for index.i in list:
print(index.i)
上面的方法会将列表重新输出成为元祖，其第一个元素就是这个元素在原来列表中的角标
list=["北京","天津","湖北","湖南"]
for Index in enumerate(list):
print(Index)
(0, '北京')
(1, '天津')
(2, '湖北')
(3, '湖南')
以元组的形式输出，这时就可以获取元组的标号和内容了
list_num=Index[0]
list_name=Index[1]
print(list_num,"$",list_name)
0 $ 北京
1 $ 天津
2 $ 湖北
3 $ 湖南
集合
是无序、去重复的一种数据类型
集合的创建
s1 = {11,22}
s2 = set{} #创建一个空集合
s3 = set（[11,22,33]） #将一个列表转换为集合，类似list
集合的操作
集合.add() 给集合中增加一个元素
s=set()
print(s)
s.add(123)
print(s)
输出
set()
{123}
集合.update（），批量更新，括号内的内容可以是列表、元组、字符串
update的执行过程就是通过for循环，循环add命令
集合.clear（）清除集合中所有的内容
集合.copy() 复制集合，浅复制，仅复制第一层
查看差集
集合A.difference（新集合B） A中存在，b中不存在的内容，不改变原集合
集合A.symmetric_difference(新集合B) 比较A和B之间都不存在的值，不改变原集合
更新集合
集合A.difference_update(新集合B），将A中存在，B中不存在的内容替换到集合A中，
s1={11,22,33}
s2={22,33,44}
print(s1)
s1.difference_update(s2)
print(s1)
输出
{33, 11, 22}
{11}
集合A.symmetric_difference_update(集合B），将集合A B中都没有的数据替换到集合A中
s1={11,22,33}
s2={22,33,44}
print(s1)
s1.symmetric_difference_update(s2)
print(s1)
输出
{33, 11, 22}
{11, 44}
集合.discard(特定元素) 移除特定的元素，不存在不报错
s1={11,22,33}
s1.discard(11)
print(s1)
输出
{33, 22}
集合.remove(特定元素) 移除特定的元素，不存在会报错
集合.pop() 随机移除元素移除元素，并把移除的元素返回，可以将其赋给一个变量
s1={111,222,333}
s=s1.pop()
print(s)
集合.intersection（新集合） ，取两个集合的交集，需要赋值
集合A.intersection_update（新集合B） ，取两个集合的交集，并将其替换到集合A中
集合A.isdisjoint(集合B），判断两个集合之间是否有交集，有就是True没有就是False
集合A.issubset(集合B），判断集合A是否是集合B的字集
集合A.issuperset（集合B），判断集合A是否是集合B的超集
集合.union（集合B），将两个集合合并，去重复。并集
关于集合的联系
当两个字典，一个字典时原先的状态记录，另一个字典时最新的状态记录，我们应该使用什么方法来确定：
什么条目应该被删除
什么条目应该被更新
什么条目应该被增加
old_status={
"1#":4,
"2#":8,
"4#":16
}
new_status={
"1#":8,
"2#":8,
"3#":16
}
#首先需要将原先字典中的key转化为集合
old_set=set(old_status.keys())
new_set=set(new_status.keys())
#需要删除的内容是：老的状态中存在，但是在新状态中却没有的
status_remove=old_set.difference(new_set)
print("status_remove：%s"%status_remove)
#需要新增的内容是：新的状态中存在，但是在老状态中没有的
status_add=new_set.difference(old_set)
print("status_add：%s"%status_add)
#需要被更新的内容是：新旧状态都存在的
status_update=old_set.intersection(new_set)
print("status_update:%s"%status_update)
输出
status_remove：{'4#'}
status_add：{'3#'}
status_update:{'1#', '2#'}
python上加颜色
\033[31;1m内容\033[0m 为红色
\033[32;1m内容\033[0m 为绿色
salary=input("\033[31;1mInputyoursalary:\033[0m")
购物车程序作业需求：
1、允许用户选择购买了多少件
2、允许多用户登录，并且下次登录后，继续按上次的余额购买，允许充值
3、允许用户查看之前的购买记录，并显示购买时间
4、商品列表分级展示
5、重复商品在一行内显示总量，不多行展示
新知识，会用到文件，datetime模块，序列化json