Python第二天课程

创建列表的方式

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