day02学习大纲

一. 格式化输出:

%s 占位字符串

%d 占位数字

"xxx%sx %sxx" % (变量, 变量)

二. 运算符:

a+=b a = a + b

and 并且. 左右两端同时为真. 结果才能是真

or 或者. 左右两端有一个是真. 结果就是真

not 非真既假, 非假既真

顺序: () => not => and => or

a or b:

如果a是0, 结果是b, 否则结果是a

a and b : 和or相反

三. 编码

ascii : 8bit 1byte, 英文字母+ 数字 + 特殊符号

gbk: 16bit 2byte, 主要是中文

unicode: 32bit 4byte

utf-8:

英文:8bit 1byte

欧洲:16bit 2byte

中文:24bit 3byte

encode() 编码成bytes字节

decode() 解码

四. 基本数据类型int和bool

int bit_length()

bool:

数据类型的转换

True: 1

False: 0

0: False

非0: True

结论: 如果想把x转化成y. y(x)

结论: 所有的空都认为是False

五. 基本数据类型str

索引和切片: 索引的下标从0开始

切片: [p:q:r] 从p到q每隔r出来1个

r如果是负数, 从右往左

常用的操作:

1. upper() 转化成大写.

2. split() 字符串切割. 切割的结果是列表

3. replace() 字符串替换

4. stript() 去掉左右两端的空白(空格, \t, \n)

5. isdigit() 判断是否是数字组成

6. startswith() 是否以xxx开头

7. find() 查找. 如果找不到返回-1

内置函数:

len()求字符串长度.

for循环

for 变量 in 可迭代对象:

循环体

in 和 not in

六 列表和元组

[元素, 元素]

列表有索引和切片

增删改查:

增加: append() insert()

删除: remove(元素) pop(索引)

修改: lst[index] = 新元素

查询: lst[index]

for item in lst:

循环体

深浅拷贝:

1. 赋值. 没有创建新列表

2. 浅拷贝. 只拷贝表面(第一层)

3. 深拷贝. 全部都拷贝一份

元组: 不可变, 主要用来存储数据

range(),可以让for循环数数(重点中的重点)

七. 字典

由{}表示. 以k:v形式保存数据

k必须可哈希. 不可变

增删改查:

1. 新增: dic['新key'] = 新value, setdefault(key, value)

2. 删除: pop(), del, cleart()

3. 修改: dic[key] = value

4. 查询: get(), dic[key], keys(), values(), items()

循环(必须要掌握):

1. for k in dic:

k

dic[k]

2. for k, v in dic.items():

k

v

八: set集合

特点: 无序, 不重复, 元素必须可哈希

add() 添加

九: is和==

is判断内存地址

==判断数据

十: 列表和字典的循环

在循环列表和字典的时候. 不能删除原来列表和字典中的内容

把要删除的内容记录在新列表中. 循环这个新列表. 删除老列表

下周要预习:

1. 文件操作

2. 函数

一、格式化输出

%s是占位字符数,实际可以占位任何东西，%s用的比较多.

%d要占位整数,只能占位数字，这时对应的数据必须是int类型. 否则程序会报错.一般用的不多.

例：现在有以下需求,让⽤用户输入name, age, job,hobby 然后输出如下所⽰示:

例2:制作标准化的名片,分别输入name,job,address,phone.自动生成名片.

代码如下：

name = input("请输入你的名字:")job = input("请输入你的工作:")address = input("请输入你的地址:")phone = input("请输入你的电话:")print('''===============%s====================Name: %s===========================Job: %s============================Address: %s======Phone: %s==================================================================''' % (name, name, job, address, phone))

如果Python3.6以上,可以使用模板字符串模板字符串f”{}”，例如：

name = "wusir"hobby = "playing basketball"print("%s love %s." %(name,hobby))print(f"{name} love {hobby}")

当出现2%或3%等%号时，使用2%%表示：例如：

hobby = "playing basketball"print("80%% of children love %s" %hobby)

二、基本运算符

计算机可以进⾏行行的运算有很多种，可不不只加减乘除这么简单，运算按种类可分为:算数运算、比较运算、逻辑运算、赋值运算、成员运算、身份运算、位运算.

1、算数运算（a=10，b=20）

2、比较运算

==和is的区别

== 比较的是数据,这两个人长得是不是一样的

Is 比较的是内存地址,这两个人是不是同一个人

例如：下列程序，第一个是True，第二个是False。

lst=[1,2,3]lst2=[1,2,3]print(lst==lst2)print(lst is lst2)

3.赋值运算

[右边是变量] = 把右边的值赋值给左边的变量,其优先级是最低的.右边的东西必须向执行.

4.算逻辑运

(1)and 并且,只要有一个不成立,就是False,左右两端同时为真,然后最终是真.比如：print（1>5 and 6>4）返回时false.

(2)or 或者,左右两端有一个是真就是真.全部是假,结果才是假.

(3)not 不,非真既假,非假既真.

(4)如果出现混合逻辑运算,先算括号(),再算not,然后是and,最后是or.

例如:

返回:False

返回True

(5)在计算机中:非1就是True,0就是False.如果a or b,if a==False 则结果是b,否则是a.

a or b:如果a=0 结果是b如果a=非0,结果是aa and b:与a or b 相反.

例题:

print(3>4 or 4<3 and 1==1)#False

print(1 < 2 and 3 < 4 or 1>2)#True

print(2 > 1 and 3 < 4 or 4 > 5 and 2 < 1)#True

print(1 > 2 and 3 < 4 or 4 > 5 and 2 > 1 or 9 < 8)#False

print(1 > 1 and 3 < 4 or 4 > 5 and 2 > 1 and 9 > 8 or 7 < 6)#False

print(not 2 > 1 and 3 < 4 or 4 > 5 and 2 > 1 and 9 > 8 or 7 < 6)#False

print(8 or 4)#8

print(0 and 3)#0

print(0 or 4 and 3 or 7 or 9 and 6)#3

三、编码的问题

ascii : 8bit 1byte, 英文字母+ 数字 + 特殊符号

gbk: 16bit 2byte, 主要是中文

unicode: 32bit 4byte

utf-8:

英文:8bit 1byte

欧洲:16bit 2byte

中文:24bit 3byte

encode() 编码成bytes字节

decode() 解码

(1)美国人发行的计算机使用的编码是ASCII.里面编码的内容都是美国人编码的方式,所以ASCII码中就是英文字母+数字+键盘上的特殊符号+操作符的编码.

(2)编码就是用特定的排列组合来表示我们的文字信息.计算机底层只认识0和1.

(3)在A由于SCII码中使用8位01组合来表示的一个ASCII码的字符.最开始只有7位,但是计算机对7不敏感,整整128个,所以为了拓展,增加了一位,变成了8byte=8bit.ASCII是只有7位是有效的,最前面的那位是空着的,0111 1111

(4)ASCII码没有中文标准,提出一个标准ANSI,在ASCII中扩展1倍.可以兼容ASCII码.即0000 0000 0111 1111

(5)给各个国家进行编码.就产生了,中国GB2312.由于GB2312逐渐扩展,产生了国标扩展码:GBK.中国的计算机上就是GBK.台湾用的大五码big5

(6)GBK共65000多个,包含了中文\中国邻国的文字\韩文\日文\繁体字.如果不能显示,就会显示????

(7)如果中国人使用德国的文字,中国的文字看不到欧洲的文字.就产生了国与国的交流码.产生了Unicode(万国码),需要扩容到了32bit.us2和us4(32bit)即:print(2**32)共42亿文字.

(8)早起的Unicode无法使用,因为(1)太大了.比ASCII码增加了8倍,即1M的英文就产生了4M的空间.(2)网络传输:传输慢,费用高.

(9)随着机能的提高和utf-8的产生,Unicode可以使用了.把Unicode重新定.义,可变长度的Unicode=>tuf-8和utf-16.

Utf-8:最小字节单位是8bit

Utf-16:最小字节单位是16bit

(9)我们用的最多的是utf-8,是从Unicode来的.

1)英文:8位,ASCII码的东西还是ASCII码.

2)欧洲的文字占16位;

3)中文占24位,因为中文有9万多个,如果出现乱码用utf-8后GBK处理.

(10)Python2默认是ASCII,Python3内存使用的Unicode,文件存储使用的utf-8.内存使用Unicode是可以的,因为内存是实时回收的.内存是可以浪费的.而硬盘是不能超标的.

(11)想要存储,必须进行转换成utf-8或GBK

一个字是3个字节,古力娜扎四个中文就是12个字节.

12.字节的作用就是存储和传输.

13.GBK的编码 一个中文2个字节,古力娜扎一共8个字节.

14.编码encode(得到的是byte类型)\解码 decode(得到的是字符串)

用什么编码,用什么解码.

即:bs.encode(“utf-8”) 解码也必须用utf-8 即 bs.decode(“utf-8”).同理GBK.

15.字符串

0,1=>1bit

8bit =>1byte

1024byte=>1kb

1024kb=>1mb

1024mb=>1gb

四、 基本数据类型int和bool

int bit_length()

bool:

数据类型的转换

True: 1

False: 0

0: False

非0: True

结论: 如果想把x转化成y. y(x)

结论: 所有的空都认为是False

1.基本数据类型:int类型的数据,基本运算.只有一个应用,bit_length()二进制长度.

0=>False

非0=> True 与正负号无关

2.While 1 和while True的区别,while 1会效率高一点.

3.你想把x转换成y,需要y(x)

例如:print(bool(“”))#能够表示False的字符串是假.

4.所有表示空的东西都是假.

比如:print(bool([0]))#列表有东西就是真. print(bool([]))#列表没有东西,就是假. print(bool(none))#none:空,真空,是假.其作用最主要的就是占位.

五、 基本数据类型str

索引和切片: 索引的下标从0开始

切片: [p:q:r] 从p到q每隔r出来1个

r如果是负数, 从右往左

常用的操作:

1. upper() 转化成大写.

2. split() 字符串切割. 切割的结果是列表

3. replace() 字符串替换

4. stript() 去掉左右两端的空白(空格, \t, \n)

5. isdigit() 判断是否是数字组成

6. startswith() 是否以xxx开头

7. find() 查找. 如果找不到返回-1

内置函数:

len()求字符串长度.

for循环

for 变量 in 可迭代对象:

循环体

in 和 not in

一、字符串str:由单引号\双引号\三引号\三双引号括号引起来的内容.即:引号引起来的都是字符串.

单引号中不能有单引号

双引号中可以有单引号.

单引号和双引号都是单行的.如果回车就会出现\ 表示下面内容和本行是同一行代码

三引号表示的是一段字符串,可以多行.

二、字符串的索引和切片

1、索引就是第几个字符,索引从0开始.

正序:012

倒叙:-3,-2.-1

[]表示索引.

-1表示倒数第一个

s = "jay"print(s[1])#aprint(s[2])#yprint(s[-1])#yprint(s[-3])#j

2、切片:拿到字符串的一部分

1)顾头不顾尾,比如[4:8]取的是4,5,6,7不能取8.

2)默认顺序:从左到右.比如[8:4],不能切出来.从8往后找不到4.

3)还可以负数切,比如[-6:-2],

4)[6:]#表示,从-6开始切到最后.

5)[:6]#表示从头开始切,切到6位

6)[:]#从头切到尾.

s = "jay is a asshole!!!!"print(s[4:8])#is aprint(s[8:4])#noneprint(s[-6:-2])#le!!print(s[6:])# a asshole!!!!print(s[:6])#jay isprint(s[:])#jay is a asshole!!!!print(s[2:8:3])#ys

3、带有步长的切片

#每2个出来一个

#步长可以为负数,表示从右到左.

#[::-1]#相当于从右到左一个一个数,整个句子放过来.

s = "jay is a asshole!!!!"print(s[3:8:2])#从3到8,每2个出来1个print(s[::2])print(s[-1:-6:-2])

三、字符串大小转换

1.首字母大写capitallize:字符串是不可变的数据类型.比如下面这个程序不能首字母大写.每次操作都会返回新字符串.

S还是原来的字符串alex

只能把改变的s赋值给S1,才能显示Alex.

s = "jay is a asshole!!!!"s1=s.capitalize()print(s)#jay is a asshole!!!!print(s1)#Jay is a asshole!!!!

2.所有字母大写:upper；全部转成成小写:lower,对一些欧洲文字不敏感.

s = "Jay Is a Asshole!!!!"s1=s.upper()s2=s.lower()print(s)#Jay Is a Asshole!!!!print(s1)#JAY IS A ASSHOLE!!!!print(s2)#jay is a asshole!!!!

例如:让用户输入的字母,需要忽略大小写.

s="Q"while True:game = input("Please input your favorite games:""Or input Q to exit")if game.upper()==s:breakprint("Your favorite game:%s" %game)

3.title()标题:每个单词的首字母大写.

s = "Jay Is a Asshole!!!!"s1=s.title()print(s1)#Jay Is A Asshole!!!!

4.字符串切割:split()#把字符串切成很多段,默认用空白切割.比如以a为切口,那么打印出来列表,没有a了.

如果没有切的刀,所以原有的字符串还是原有的字符串.

如果刀卡到了边缘.只要下刀了,至少会有两段,用’’空字符串表示.如果下刀的地方是边缘,一定能获得空字符串.

s = "alex_wusir_taibai"ret = s.split("_")print(ret)#['alex', 'wusir', 'taibai']print(type(ret))#<class 'list'>

5.字符串的替换:replace

s = "alex_wusir_taibai"ret=s.replace("sir","先生")print(ret)

6.strip() 去左右两端的空白,=>脱掉空白

\t #tab,就空格,即制表符,首行缩进2个字符.

\n #newlines 换行

s = "\talex_wusir\t_taibai\t"ret=s.strip()print(s)# alex_wusir _taibai 前后有空格print(ret)#alex_wusir _taibai

应用：防止客户输入的alex+空格,无法检查出来

Strip(“a”)去掉字符串两端的a.

username = input("用户名:").strip()password = input("输密码:").strip()if username == "ken" and password =="123":print("登录成功!")else:print("用户名或密码错误")

7.判断这句话是否是***开头,start.with() 判断是以***结尾endwith()

例如：一般应用于判断姓氏。判断开头或结尾是不是“alex”

s = "alex_wusir_taibai"print(s.startswith("alex"))#Trueprint(s.endswith("alex"))#False

8.count(“a”)#计算某XX出现的次数.

9.s.find()#找到是索引

如果不存在,返回-1

如果存在,从左到右,第一个位置.

s = "alex_wusir_taibai"print(s.count("a"))#3print(s.find("a"))#0print(s.find("i"))#8

10.isdigit()#判断是否为数字构成.

11.isalpha()只能判断非数字,判断是否由文字的基础组成.所以加上华辣汤后也是True.

12.isalnum判断是否由数字和字母构成,能屏蔽特殊字符.

13.isnumeric():能判断中文的数字,但不认识”两”和”俩”.

s = "asd123"a = "壹贰三四"print(s.isdigit())#Falseprint(s.isalpha())#Falseprint(a.isnumeric())#Trueprint(s.isalnum())#True

14.len()#求字符串的长度,内置函数

例如：比如打印“kenments”每个字母

s = "kenments"i=0while i<len(s):print(s[i])i+=1

15.for循环，比上面案例更简单

for 变量 in 可迭代(iterable)对象:

循环体

#可迭代:能够一个一个的拿出来,拍出来.字符串就是可迭代对象.

#把字符串的中每个一个字符赋值给变量c

s = "kenments"for c in s:print(c)

C就是字符变量a,l,e,x.

#但是数字不能放,比如 for i in 10:

16. in/not in #成员运算,

比如判断某某是我们班的成员.应用最多的方面就是评论区/禁言等敏感字词.

比如:s=”alex特别喜欢麻花藤”#麻花藤是敏感词.

s ="ken is a good man!"if "ken" in s:print("sorry,you can't write")else:print("OK,No problem!")

8.while…else…

For…else…

和if…else…一样的

Break不会执行else,他直接打断这个循环,不执行else,这是一个大坑.

For循环和while循环一样,也可以使用break\continue和else.

For只有迭代完成后,才执行else.

i=0while i<100:print(i)if i == 66:breaki+=1else:print("It's Done")

六、列表和元组

（一）列表:能装对象的对象:一个能装东西的对象,比如把东西装包里.

列表是一个可迭代对象,可循环

存在的意义:存储大量的数据.

(1)如果字符串的话,需要切片,比较麻烦.

(2)列表使用[]括起来,内部元素用,逗号隔开.

List=[“张三丰”,”张无忌”,”张无忌”]

(3)列表和字符串也有索引和切片

Print(list[1])#索引张无忌

Print(list[1::2])#切片

list = ["Ken","Lucy","Tom","John"]print(list[1])#索引 Lucyprint(list[::2])#切片#['Ken', 'Tom']print(list[-1::-2])#从右每2个切#['John', 'Lucy']

(4)列表的增删改查

#增加

1)append:追加,向列表的最后放数据.

空列表的创建:list[]或list()

append只能参加一个

list = []list.append("lucy")list.append("ken")print(list)#['lucy', 'ken']

2)insert()#插入\加塞

下面存在问题,后排的位置都后移,效率较低.

list = ["Ken","Lucy","Tom","John"]list.insert(2,"Lily")print(list)

3)迭代添加:extend()

一个一个的叠加.

主要应用在两个列表中,进行融合.

list = ["Ken","Lucy","Tom","John"]list.extend("兽兽")list.extend("Lily")print(list)#['Ken', 'Lucy', 'Tom', 'John', '兽', '兽', 'L', 'i', 'l', 'y']

两个列表融合

list = ["Ken","Lucy","Tom","John"]list1 = ["大米","玉米","石头"]list.extend(list1)print(list)#['Ken', 'Lucy', 'Tom', 'John', '大米', '玉米', '石头']

#删除

1) pop(1)#制定位置删除

2) remove(“麻花藤”)#删除,制定某个元素删除.

3) Del list(3)#删除第三个

4) List.clear#清空.

list = ["Ken","Lucy","Tom","John"]list.pop(2)print(list)#['Ken', 'Lucy', 'John']list.remove("John")print(list)#['Ken', 'Lucy']del list[1]print(list)#['Ken', 'Tom', 'John']list.clear()print(list)#[]

#修改

list[1]=”东北一家人”#制定某位置的元素,修改成XXX

最常用的索引修改.

list = ["Ken","Lucy","Tom","John"]list[1]="大米"print(list)#['Ken', '大米', 'Tom', 'John']

#查询+成员判断

list = ["Ken","Lucy","Tom","John"]list[1]="大米"print(list)#['Ken', '大米', 'Tom', 'John']print(list[2])#Tomfor item in list:print(item)#打印每个元素print("大米" in list)#True#成员判断

#list.sort() 排序,升序

#list.reverse() 降序

list = ["Ken","Lucy","Tom","John"]list1 = [1,6,5,4,36]list.sort#['John', 'Ken', 'Lucy', 'Tom']list.reverse()print(list)#['Tom', 'Lucy', 'Ken', 'John']list1.sort()print(list1)#[1, 4, 5, ()print(list)6, 36]list1.reverse()print(list1)#[36, 6, 5, 4, 1]

#深浅拷贝

1)Python中的赋值

Python内部的运行过程,比如a=10,在内存先给10,然后想办法给a,a通过内存地址1A2B,找到10.

如果变量a赋值20,那么20的内存地址eee,则a通过内存eee,找到20.

如果b=a,彼此a放的是eee,所以变量赋值b为内存地址eee.所以a和b是同一个数据.

赋值操作没有拷贝,是同一个地址.

a = [1,6,5,4]b =ab.append(888)print(a)#[1, 6, 5, 4, 888]print(b)#[1, 6, 5, 4, 888]

赋值操作没有创建新列表.

如果b=a[:]#此时对a进行了复制.此时创建了新的列表.

a = [1,6,5,4]b =a[:]b.append(888)print(a)#[1, 6, 5, 4]print(b)#[1, 6, 5, 4, 888]

2)浅拷贝:先按照样子复制一个新内存地址.内存地址不一样.给a添加444,b不变.

浅拷贝的问题就是只抄个地址.其有附件就有问题.

3)这就是深拷贝,其问题的情况需要复制一份自地址.

一般情况使用浅拷贝,省内存.如果涉及到两个操作,都有可能操作你的列表,那此时需要深拷贝.

a = [1,2,3,4,[5,6,7],[7,9,8],"附件1"]

b = a.copy()

c = a.deepcopy()

b.append("444")

print(a)#[1, 2, 3, 4, [5, 6, 7], [7, 9, 8], '附件1']

print(b)#[1, 2, 3, 4, [5, 6, 7], [7, 9, 8], '附件1', '444']#b不能copy附件1

print(c)#[1, 2, 3, 4, [5, 6, 7], [7, 9, 8], '附件1', '444']#c不能copy附件1

(二)元组

元组是不可变的列表:只能看,不能干

元组用小括号()表示,并且空元祖用tuple(),如果元组中只有一个元素,必须在后面加逗号.

但如果只有一个元素,比如tu=(1)或tu=(“sjdkf”),那么统type的格式int和str.因此元组后面必须加逗号,如:tu=(“sd”,)

元组是可迭代的

ken=("金庸","古龙","黄奕","孙晓")john=("金庸")lily=("金融",)print(type(ken),type(john),type(lily))#<class 'tuple'> <class 'str'> <class 'tuple'>for item in ken:print(item)#元组是可迭代的

七.字典

1.字典的存在意义:就是快,根据hash值(散乱的)存储的,字典中所有的key必须是可哈希的.

2.字典用{}表示,以key:value的形式保存数据.

3.{}大括号是字典,[]中括号是列表,()小括号是元组.

比如:

dictionary={"北京":"政治中心","上海":"金融中心","深圳":"改革中心","台湾":"收复重心"}

4.不可变就是hash值.

###查询

要想查询,必须知道key

dictionary={"北京":"政治中心","上海":"金融中心","深圳":"改革中心","台湾":"收复重心"}print(dictionary["北京"])#弊端就是:如果没有这个可以,就会报错.print(dictionary["台湾"])

print(dictionary["广州"])#报错

print(dictionary.get("广州","没有这个人" ))#没有这个人

###添加

方法1:直接添加

dictionary={"北京":"政治中心","上海":"金融中心","深圳":"改革中心","台湾":"收复重心"}dictionary["重庆"]="辣椒之都"print(dictionary)

dictionary={"北京":"政治中心","上海":"金融中心","深圳":"改革中心","台湾":"收复重心"}dictionary["重庆"]="辣椒之都"#不存在就添加print(dictionary)#{'北京': '政治中心', '上海': '金融中心', '深圳': '改革中心', '台湾': '收复重心', '重庆': '辣椒之都'}dictionary["北京"]="外交中心"#存在就修改print(dictionary)#{'北京': '外交中心', '上海': '金融中心', '深圳': '改革中心', '台湾': '收复重心', '重庆': '辣椒之都'}

方法2:dictionary.setdefault["西安","古都之城"]

#如果只有一个参数,value放空.如果有两个参数,就可以新增.

Setdifault执行流程:

1.首先判断你的key有没有出现,如果出现了,就不执行任何操作,如果没有出现,就执行新增.

2.不论前面是否执行新增,最后都会把对应的key的value查询出来.

不管key:value存在不存在,都查出一个结果.

dictionary={"北京":"政治中心","上海":"金融中心","深圳":"改革中心","台湾":"收复重心"}dictionary.setdefault("西安","古都之城")print(dictionary)#{'北京': '政治中心', '上海': '金融中心', '深圳': '改革中心', '台湾': '收复重心', '西安': '古都之城'}dictionary.setdefault("西安")print(dictionary)#{'北京': '政治中心', '上海': '金融中心', '深圳': '改革中心', '台湾': '收复重心', '西安': None}

应用场景:对列表

[11,12,33,44,55,66,77,88,99],在key1放小于66,key2放大于60.

第一种方式:比较麻烦

lst= [11,22,33,44,55,66,77,88,99,100]ret ={}for item in lst:if item < 66:if not ret.get("key01"):ret["ken01"]=[item]else:ret["ken01"].append(item)else:if not ret.get("key02"):ret["key02"]=[item]else:ret["key02"].append(item)print(ret)

第二种方法:

lst= [11,22,33,44,55,66,77,88,99,100]ret={}for item in lst:if item < 60:ret.setdefault("key01",[]).append(item)else:ret.setdefault("key02",[]).append(item)print(ret)

###删除

dic.pop(“alex”)#根据key去删除

dic.clear()#清空

del dic[“wusir”]#根据key删除.

dictionary={"北京":"政治中心","上海":"金融中心","深圳":"改革中心","台湾":"收复重心"}dictionary.pop("北京")print(dictionary)#{'上海': '金融中心', '深圳': '改革中心', '台湾': '收复重心'}del dictionary["上海"]print(dictionary)#{'深圳': '改革中心', '台湾': '收复重心'}dictionary.clear()print(dictionary)#{}

###查询

Keys() #找到keys

dictionary={"北京":"政治中心","上海":"金融中心","深圳":"改革中心","台湾":"收复重心"}print(dictionary.keys())#dict_keys(['北京', '上海', '深圳', '台湾'])print(dictionary.values())#dict_values(['政治中心', '金融中心', '改革中心', '收复重心'])print(dictionary.items())#dict_items([('北京', '政治中心'), ('上海', '金融中心'), ('深圳', '改革中心'), ('台湾', '收复重心')])

dic.value() #获取的所有value

字典只能通过key去找value,不能用value找key.

dic.item()#获取的是元组

通过元组拿到了key和value

dictionary={"北京":"政治中心","上海":"金融中心","深圳":"改革中心","台湾":"收复重心"}print(dictionary.items())for i in dictionary.items():print(i)k = i[0]v = i[1]print(k,v)

解构和解包(数据和变量要一一对应)

a,b=1,2#1,2是元组,把元组中每一项赋值给前面的变量,叫解包.同a,b=(1,2),但a,b=(1,2,3,),不能解包.

dictionary={"北京":"政治中心","上海":"金融中心","深圳":"改革中心","台湾":"收复重心"}#方法一for item in dictionary.items():k,v = itemprint(k,v)#方法二:for k,v in dictionary.items():print(k,v)

(4)字典的嵌套

字典不能当key,因为字典是可变的

当字典嵌套很多层,需要换行

wf = {"name":"wangfeng","age":42,"wife":{"name":"guojizhang","age":41,"hobby":["拍戏","当导师"],"assit":{"name":"zhulizhang","age":28}},"children":[{"name":"xiao1hao","age":18},{"name":"xiao2hao","age":15},{"name":"xiao3hao","age":2}]}#查询汪峰二儿子的年龄print(wf["children"][1]["age"])#15#查询汪峰助理的年龄print(wf["wife"]["assit"]["age"])#28#该汪峰的小儿子加10岁wf['children'][2]['age']=wf['children'][2]['age']+10print(wf["children"][2]["age"])

八.集合set

1.set集合,无序\不重复\内部元素可hash

2.set集合用大括号表示,如果是空集合,用set().例如set{}这是字典,而set{1,2}是set集合.

3.打印出来的是无序的,每次都不一样.

4.最大的作用去重

5.添加s.add()

6.删除

s.pop()#随机删除

s.remove(“炖鸡”)#定向删除

7.集合不能修改,只能先删除再添加

8.查找

For el in s:

Print(s)

s = ["公平","正义","英雄","战役","公正","公平","战役"]a=set(s)print(a)#{'公平', '正义', '战役', '英雄', '公正'}a.add("自由")print(a)#{'战役', '正义', '公正', '英雄', '公平', '自由'}b=list(a)a.pop()print(a)#随机删除{'战役', '英雄', '公平', '正义', '自由'}a.remove("战役")print(a)#定向删除{'自由', '正义', '公正', '英雄'}print(b)#['公平', '正义', '战役', '英雄', '公正']

九.is和==

== 比较的是数据,这两个人长得是不是一样的

Is 比较的是内存地址,这两个人是不是同一个人.

a=[1,2,3]b=[1,2,3]print(a==b)#Trueprint(a is b)#False

十.列表的循环删除

I=0,开始,jay删了,jj和jolin等前移.

如何删除

记录删除的元素:

#删除列表中所有内容#错误展示lst = ["Ken","Lucy","Tom","John","Lily","Kate"]for item in lst:lst.remove(item)print(lst)#['Lucy', 'John', 'Kate']

#正确的方式1lst = ["Ken","Lucy","Tom","John","Lily","Kate"]s = lst[:]for item in s:lst.remove(item)print(lst)#[]

lst = ["Ken","Lucy","Tom","John","Lily","Kate"]s=[]for item in lst:s.append(item)for item in s:lst.remove(item)print(lst)#[]print(s)#['Ken', 'Lucy', 'Tom', 'John', 'Lily', 'Kate']

十一.range,让for循环数数

打印1-99

for i in range(99):print(i)for i in range(10,20):print(i)for i in range(10,20,2):print(i)

可以拿到索引和元素

lst =["金城武","李嘉诚","鹿晗","韩丽","李易峰","李明"]for i in range(len(lst)):print(i,lst[i])# 0 金城武# 1 李嘉诚# 2 鹿晗# 3 韩丽# 4 李易峰# 5 李明

十二.练习题

删除姓李的

lst =["金城武","李嘉诚","鹿晗","韩丽","李易峰","李明"]new_lst=lst[:]for i in new_lst:if i.startswith("李"):lst.remove(i)print(lst)#['金城武', '鹿晗', '韩丽']

字典删除

d={"北京":"政治中心","上海":"金融中心","深圳":"改革中心","台湾":"收复重心"}n = []for k in d:n.append(k)for k in n:d.pop(k)print(d)#{}