day02 格式化输出运算符编码字符串列表元组字典 set集合深浅拷贝

最新推荐文章于 2024-06-14 09:50:01 发布

weixin_30254435

最新推荐文章于 2024-06-14 09:50:01 发布

阅读量487

点赞数

文章标签： python

原文链接：http://www.cnblogs.com/kenments/p/10241216.html

版权

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,结果是a
a 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])#a
print(s[2])#y
print(s[-1])#y
print(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 a
print(s[8:4])#none
print(s[-6:-2])#le!!
print(s[6:])# a asshole!!!!
print(s[:6])#jay is
print(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:
        break
    print("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"))#True
print(s.endswith("alex"))#False

8.count(“a”)#计算某XX出现的次数.
9.s.find()#找到是索引
如果不存在,返回-1
如果存在,从左到右,第一个位置.

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

10.isdigit()#判断是否为数字构成.
11.isalpha()只能判断非数字,判断是否由文字的基础组成.所以加上华辣汤后也是True.
12.isalnum判断是否由数字和字母构成,能屏蔽特殊字符.
13.isnumeric():能判断中文的数字,但不认识”两”和”俩”.

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

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

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

s = "kenments"
i=0
while 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=0
while i<100:
    print(i)
    if i == 66:
        break
    i+=1
else:
    print("It's Done")

六、列表和元组

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

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

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

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

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

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

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

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

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

list = ["Ken","Lucy","Tom","John"]
print(list[1])#索引 Lucy
print(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])#Tom
for 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 =a
b.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 = item
    print(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']+10
print(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)#True
print(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']

#正确的方式1
lst = ["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)#{}

转载于:https://www.cnblogs.com/kenments/p/10241216.html

weixin_30254435

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
day02 格式化输出运算符编码字符串列表元组字典 set集合深浅拷贝

day02学习大纲一. 格式化输出: %s 占位字符串 %d 占位数字 "xxx%sx %sxx" % (变量, 变量)二. 运算符: a+=b a = a + b and 并且. 左右两端同时为真. 结果才能是真 or 或者. 左右两端有一个是真. 结果就是真 not 非真既假, 非假既真顺序: () => not => an...
复制链接

扫一扫