python学习day2

一、模块初识(库)

1.1标准库

不需要安装,直接可以导入的库,python非常常用的一些功能

  • 学习其中两个模块sys和os
  1. #Chuck Ma
  2. import sys
  3. print(sys.path) #sys为标准模块,path为sys的方法,两者由点分割;默认是从系统导入,如果当前目录有和要导入模块相同的文件名,则是优先导入当前目录下的文件,也就是说不要起和导入库相同的文件名;
  4. #以下为输出结果,打印的结果是python的全局变量定义的路径。其实就是一个路径的列表,例如sys模块必然存在以下某个路径之一下,path为打印其环境变量
  5. C:\Users\hexun\AppData\Local\Programs\Python\Python35-32\python.exe C:/Users/hexun/PycharmProjects/chuck/day2/os2.py
  6. ['C:\\Users\\hexun\\PycharmProjects\\chuck\\day2', 'C:\\Users\\hexun\\PycharmProjects\\chuck', 'C:\\Users\\hexun\\AppData\\Local\\Programs\\Python\\Python35-32\\python35.zip', 'C:\\Users\\hexun\\AppData\\Local\\Programs\\Python\\Python35-32\\DLLs', 'C:\\Users\\hexun\\AppData\\Local\\Programs\\Python\\Python35-32\\lib', #标准库存放路径 'C:\\Users\\hexun\\AppData\\Local\\Programs\\Python\\Python35-32', 'C:\\Users\\hexun\\AppData\\Local\\Programs\\Python\\Python35-32\\lib\\site-packages'] #第三方标准库的存放路径
  • sys的其他方法

    其中args为打印文件名,后面的1 2 3为传参参数,输出结果为一个列表,后续有详细解释。
  • 学习os模块,是从python调用shell模块
  1. import os
  2. cmd_result = os.system("dir") #只执行命令,不保存结果
  3. print("----->>>",cmd_result)
  4. .
  5. .
  6. .
  7. ----->>> 0 #此结果会得到返回码,0代表成功,其他代表失败
  • 使用os模块执行命令,保存结果
  1. import os
  2. cmd_result = os.popen("dir")
  3. print("----->>>",cmd_result)
  4. ----->>> <os._wrap_close object at 0x0032E310> #打印内存对象地址
  • 读出dir的结果
  1. import os
  2. cmd_result = os.popen("dir").read() #将上述内存地址使用read方法读出
  3. print("----->>>",cmd_result)
  4. 2016/07/30 14:18 329 os.py
  5. 2016/08/01 22:17 161 os2.py
  • 使用os创建目录
  1. import os
  2. os.mkdir("first")
  3. os.system("mkdir second")

1.2第三方库

必须要下载安装才可以使用,例如django,自己写的也可以放到第三方库中,首先到当前目录找此模块,当前目录找不到会到全局变量中找此模块,如果想要自己写的模块生效,需要把自己写的模块放到site-package下,或者在全局变量下增加自己的文件夹即可,在py文件中中直接import即可。

二、告诉你pyc是什么

在python3.5版本后,py文件执行在__pycache__目录,下面会有python所执行后生成的.pyc文件,下面对pyc进行解释:

2.1 Python是一门解释型语言?

我初学Python时,听到的关于Python的第一句话就是,Python是一门解释性语言,我就这样一直相信下去,直到发现了.pyc文件的存在。如果是解释型语言,那么生成的.pyc文件是什么呢?c应该是compiled的缩写才对啊!
为了防止其他学习Python的人也被这句话误解,那么我们就在文中来澄清下这个问题,并且把一些基础概念给理清。

2.2 解释型语言和编译型语言

计算机是不能够识别高级语言的,所以当我们运行一个高级语言程序的时候,就需要一个“翻译机”来从事把高级语言转变成计算机能读懂的机器语言的过程。这个过程分成两类,第一种是编译,第二种是解释。
编译型语言在程序执行之前,先会通过编译器对程序执行一个编译的过程,把程序转变成机器语言。运行时就不需要翻译,而直接执行就可以了。最典型的例子就是C语言。
解释型语言就没有这个编译的过程,而是在程序运行的时候,通过解释器对程序逐行作出解释,然后直接运行,最典型的例子是Ruby。
通过以上的例子,我们可以来总结一下解释型语言和编译型语言的优缺点,因为编译型语言在程序运行之前就已经对程序做出了“翻译”,所以在运行时就少掉了“翻译”的过程,所以效率比较高。但是我们也不能一概而论,一些解释型语言也可以通过解释器的优化来在对程序做出翻译时对整个程序做出优化,从而在效率上超过编译型语言。
此外,随着Java等基于虚拟机的语言的兴起,我们又不能把语言纯粹地分成解释型和编译型这两种。
用Java来举例,Java首先是通过编译器编译成字节码文件,然后在运行时通过解释器给解释成机器文件。所以我们说Java是一种先编译后解释的语言。

2.3 Python到底是什么

其实Python和Java/C#一样,也是一门基于虚拟机的语言,我们先来从表面上简单地了解一下Python程序的运行过程吧。
当我们在命令行中输入python hello.py时,其实是激活了Python的“解释器”,告诉“解释器”:你要开始工作了。可是在“解释”之前,其实执行的第一项工作和Java一样,是编译。
熟悉Java的同学可以想一下我们在命令行中如何执行一个Java的程序:

  1. javac hello.java
  2. java hello

只是我们在用Eclipse之类的IDE时,将这两部给融合成了一部而已。其实Python也一样,当我们执行python hello.py时,他也一样执行了这么一个过程,所以我们应该这样来描述Python,Python是一门先编译后解释的语言。

2.4 简述Python的运行过程

在说这个问题之前,我们先来说两个概念,PyCodeObject和pyc文件。
我们在硬盘上看到的pyc自然不必多说,而其实PyCodeObject则是Python编译器真正编译成的结果。我们先简单知道就可以了,继续向下看。
当python程序运行时,编译的结果则是保存在位于内存中的PyCodeObject中,当Python程序运行结束时,Python解释器则将PyCodeObject写回到pyc文件中。
当python程序第二次运行时,首先程序会在硬盘中寻找pyc文件,如果找到,则直接载入,否则就重复上面的过程。
所以我们应该这样来定位PyCodeObject和pyc文件,我们说pyc文件其实是PyCodeObject的一种持久化保存方式。

三、python数据类型

3.1数字

2 是一个整数的例子。
长整数 不过是大一些的整数。
3.23和52.3E-4是浮点数的例子。E标记表示10的幂。在这里,52.3E-4表示52.3 * 10-4。
(-5+4j)和(2.3-4.6j)是复数的例子,其中-5,4为实数,j为虚数,数学中表示复数是什么?。

3.1.1int(整型)

在32位机器上,整数的位数为32位,取值范围为-2^31~2^31-1,即-2147483648~2147483647
在64位系统上,整数的位数为64位,取值范围为-2^63~2^63-1,即-9223372036854775808~9223372036854775807

3.1.2long(长整型)

跟C语言不同,Python的长整数没有指定位宽,即:Python没有限制长整数数值的大小,但实际上由于机器内存有限,我们使用的长整数数值不可能无限大。

  • 注意,自从Python2.2起,如果整数发生溢出,Python会自动将整数数据转换为长整数,所以如今在长整数数据后面不加字母L也不会导致严重后果了。

3.1.3float(浮点型)

浮点数用来处理实数,即带有小数的数字。类似于C语言中的double类型,占8个字节(64位),其中52位表示底,11位表示指数,剩下的一位表示符号。

3.1.4complex(复数)

  复数由实数部分和虚数部分组成,一般形式为x+yj,其中的x是复数的实数部分,y是复数的虚数部分,这里的x和y都是实数。
注:Python中存在小数字池:-5 ~ 257

3.2布尔值

  • 真或假
  • 1 或 0

3.3 字符串

  1. "hello world"
  • 万恶的字符串拼接:
    python中的字符串在C语言中体现为是一个字符数组,每次创建字符串时候需要在内存中开辟一块连续的空,并且一旦需要修改字符串的话,就需要再次开辟空间,万恶的+号每出现一次就会在内从中重新开辟一块空间。
    字符串格式化输出
  1. 1
  2. 2
  3. 3
  4. 4
  5. name = "chuck"
  6. print "i am %s " % name
  7. #输出: i am chuck

注: 字符串是 %s;整数 %d;浮点数%f

  • 字符串常用功能:
    移除空白,分割,长度,索引,切片。

3.4 列表(具体在下一章会有详细的详解)

  • 创建列表:
  1. name_list = ['alex', 'seven', 'eric']
  2. name_list list(['alex', 'seven', 'eric'])
  • 基本操作
    索引,切片,追加,删除,长度,循环,包含

3.5远祖

远祖其实就是一种不可变的列表,内容不允许改变。

  • 创建元组
  1. ages = (11, 22, 33, 44, 55)
  2. ages = tuple((11, 22, 33, 44, 55))
  • 常用操作
    索引,新增,删除,键值对,循环,长度

四、数据运算

4.1算数运算

4.2比较运算

4.3赋值运算

4.4逻辑运算

4.5成员运算

4.6身份运算

4.7位运算

  • 附位运算代码
  1. #!/usr/bin/python
  2. a = 60 # 60 = 0011 1100
  3. b = 13 # 13 = 0000 1101
  4. c = 0
  5. c = a & b; # 12 = 0000 1100
  6. print "Line 1 - Value of c is ", c
  7. c = a | b; # 61 = 0011 1101
  8. print "Line 2 - Value of c is ", c
  9. c = a ^ b; # 49 = 0011 0001
  10. print "Line 3 - Value of c is ", c
  11. c = ~a; # -61 = 1100 0011
  12. print "Line 4 - Value of c is ", c
  13. c = a << 2; # 240 = 1111 0000
  14. print "Line 5 - Value of c is ", c
  15. c = a >> 2; # 15 = 0000 1111
  16. print "Line 6 - Value of c is ", c

4.8运算符优先级

4.9三元运算

  1. result = 1 if 条件 else 2

如果条件为真:result = 值1
如果条件为假:result = 值2

  1. a,b,c = 1,2,3
  2. d = a if a < b else c
  3. print(d)
  4. d = a if a > b else c
  5. print(d)

4.10十六进制

  1. 二进制,01
  2. 八进制,01234567
  3. 十进制,0123456789
  4. 十六进制,0123456789ABCDEF 二进制到16进制转换

请点击:十六进制和二进制的对应关系

五、python3的bytes和str之别

Python 3最重要的新特性大概要算是对文本和二进制数据作了更为清晰的区分。文本总是Unicode,由str类型表示,二进制数据则由bytes类型表示。Python 3不会以任意隐式的方式混用str和bytes,正是这使得两者的区分特别清晰。你不能拼接字符串和字节包,也无法在字节包里搜索字符串(反之亦然),也不能将字符串传入参数为字节包的函数(反之亦然).

5.1string转为二进制(bytes)

有些时候字符串不能处理需要转换为二进制,使用decode

  1. print(b'\xe5\xb8\x85\xe5\x93\xa5'.decode("utf-8"))
  1. chuck = "帅哥"
  2. print(chuck.encode("utf-8").decode("utf-8"))

5.2bytes转为string

在python3中socket传输数据是不可以用string形式传输的,
所以必须将str转换为bytes,使用encode

  1. chuck = "帅哥"
  2. print(chuck.encode("utf-8")) #python3如果encode处不指定utf-8或其他编码,会使用系统默认使用utf-8,python2会默认使用系统的编码

六、列表

实际生产中,如果有需求定义很多变量,肯定不会是一个个去指定,这时候就需要列表登场了,上文也提到了列表的基本操作;下面就开始对列表进行详细的学习。

6.1 打印列表

列表使用大括号定义,每个元素使用逗号隔开

  1. names = ["zhangsan","lisi","wangerma","maliang","chuck"]
  2. print(names)
  3. ['zhangsan', 'lisi', 'wangerma', 'maliang', 'chuck']

从列表中取出zhangsan,计算机是从0开始计算顺序的,所以张三对于names列表处于第0个位置,下标即为0,方法如下:

  1. names = ["zhangsan","lisi","wangerma","maliang","chuck"]
  2. print(names[0])
  3. zhanngsan

从列表中取出maliang

  1. names = ["zhangsan","lisi","wangerma","maliang","chuck"]
  2. print(names[3])
  3. maliang

6.2列表的增删改查

6.2.1列表的切片

从列表中取出lisi和wangerma,切片的宗旨是顾首不顾尾,所以如果想取到wangerma的值就需要向后移一个位置,方法如下:

  1. names = ["zhangsan","lisi","wangerma","maliang","chuck"]
  2. print(names[1:3])
  3. ['lisi', 'wangerma']

列表中最后一个值可以用-1指定,倒数第二个为-2,以此类推

  1. names = ["zhangsan","lisi","wangerma","maliang","chuck"]
  2. print(names[-1])
  3. chuck

取出最后两个元素,-2后面要省略不写

  1. names = ["zhangsan","lisi","wangerma","maliang","chuck"]
  2. print(names[-2:])
  3. ['maliang', 'chuck']

取出前三个元素,可以使用以下方法,冒号前面是0可以忽略

  1. names = ["zhangsan","lisi","wangerma","maliang","chuck"]
  2. print(names[:3])
  3. ['zhangsan', 'lisi', 'wangerma']

在列表中使用步长跳着切片,从0打印到-1(0和-1可以省略),步长为2

  1. names = ["zhangsan","lisi",["zzz","xxx","yyy"],"wangerma","maliang","chuck"]
  2. print(names[0:-1:2])
  3. ['zhangsan', ['zzz', 'xxx', 'yyy'], 'maliang']

6.2.2列表元素的增加

使用append追加,直接追加到列表最后,方法如下:

  1. names = ["zhangsan","lisi","wangerma","maliang","chuck"]
  2. names.append("mayun")
  3. print(names)
  4. ['zhangsan', 'lisi', 'wangerma', 'maliang', 'chuck', 'mayun']

使用insert加入,添加到某个元素的前面,指定该元素的下标插入,方法如下:

  1. names = ["zhangsan","lisi","wangerma","maliang","chuck"]
  2. names.insert(2,"liuqiangdong")
  3. print(names)
  4. ['zhangsan', 'lisi', 'liuqiangdong', 'wangerma', 'maliang', 'chuck']

6.2.3列表元素的修改

直接对列表的元素重新赋值修改

  1. names = ["zhangsan","lisi","wangerma","maliang","chuck"]
  2. names[2] = "liyanhong"
  3. print(names)
  4. ['zhangsan', 'lisi', 'liyanhong', 'maliang', 'chuck']

6.2.4列表元素的删除

使用remove方法

  1. names = ["zhangsan","lisi","wangerma","maliang","chuck"]
  2. names.remove("lisi")
  3. print(names)

使用del方法

  1. names = ["zhangsan","lisi","wangerma","maliang","chuck"]
  2. del names[1]
  3. print(names)
  4. ['zhangsan', 'wangerma', 'maliang', 'chuck']

使用pop方法删除,此方法默认会删除最后一个元素,也可以指定下标删除

  1. names = ["zhangsan","lisi","wangerma","maliang","chuck"]
  2. names.pop(2)
  3. print(names)
  4. ['zhangsan', 'lisi', 'maliang', 'chuck']

6.3列表的索引index

使用index方查找已知的元素在列表中的位置,如果元素不存在,则报错

  1. names = ["zhangsan","lisi","wangerma","maliang","chuck"]
  2. print(names.index("wangerma"))
  3. 2

再将wangerma从索引结果中取出来

  1. names = ["zhangsan","lisi","wangerma","maliang","chuck"]
  2. print(names.index("wangerma"))
  3. print(names[names.index("wangerma")])
  4. 2
  5. wangerma

6.4统计列表中某个元素的数量

使用count方法可以统计某个元素的数量

  1. names = ["zhangsan","lisi","wangerma","maliang","chuck"]
  2. names.insert(3,"zhangsan")
  3. names.insert(3,"zhangsan")
  4. print(names.count("zhangsan"))
  5. 3

6.5clear清空列表

使用clear可以清空列表的所有内容

6.6reverse反转列表

  1. names = ["zhangsan","lisi","wangerma","maliang","chuck"]
  2. names.reverse()
  3. print(names)
  4. ['chuck', 'maliang', 'wangerma', 'lisi', 'zhangsan']

6.7使用sort排序

sort能够将列表中的元素排序,规则优先级为:特殊字符,数字,大写字母,小写字母

  1. names = ["zhangsan","lisi","wangerma","maliang","chuck"]
  2. names.insert(1,"Liudehua")
  3. names.insert(3,"23fdsd")
  4. names.insert(4,"!^ksdk")
  5. names.sort()
  6. print(names)
  7. ['!^ksdk', '23fdsd', 'Liudehua', 'chuck', 'lisi', 'maliang', 'wangerma', 'zhangsan']

6.7使用extend连接两个列表

使用extend将names2列表连接到names上,实际上会将元素追加到names列表后面,删除names2,并不影响names这个列表

  1. names = ["zhangsan","lisi","wangerma","maliang","chuck"]
  2. names2 = ["www","jjj","lll"]
  3. names.extend(names2)
  4. del names2
  5. print(names)
  6. ['zhangsan', 'lisi', 'wangerma', 'maliang', 'chuck', 'www', 'jjj', 'lll']

6.8使用copy复制一个列表

使用copy将names复制一个names3

  1. names = ["zhangsan","lisi","wangerma","maliang","chuck"]
  2. names3 = names.copy()
  3. print(names)
  4. print(names3)
  5. ['zhangsan', 'lisi', 'wangerma', 'maliang', 'chuck']
  6. ['zhangsan', 'lisi', 'wangerma', 'maliang', 'chuck']

更改names中一个元素,打印names和name3,可以看到names列表变化了,但是names3并没有变化,我们称之为浅copy

  1. names = ["zhangsan","lisi","wangerma","maliang","chuck"]
  2. names3 = names.copy()
  3. names[2] = "hehe"
  4. print(names)
  5. print(names3)
  6. ['zhangsan', 'lisi', 'hehe', 'maliang', 'chuck']
  7. ['zhangsan', 'lisi', 'wangerma', 'maliang', 'chuck']

在names列表中加入一个列表,并更改加入列表的元素的内容,再使用copy出一个names3列表,从下面结果可以看出copy只是copy了最外面一层的元素(wagnerma),对列表中列表里的元素不再做copy,所以称之为浅copy。因为列表中的列表属于第二层元素,指向的是固定的一个内存地址,所以只要通过一个列表改动列表中列表的元素,其他的列表也都会改变

  1. names = ["zhangsan","lisi",["zzz","xxx","yyy"],"wangerma","maliang","chuck"]
  2. names3 = names.copy()
  3. names[3] = "hehe"
  4. names[2][2] = "ttt"
  5. print(names)
  6. print(names3)
  7. ['zhangsan', 'lisi', ['zzz', 'xxx', 'ttt'], 'hehe', 'maliang', 'chuck']
  8. ['zhangsan', 'lisi', ['zzz', 'xxx', 'ttt'], 'wangerma', 'maliang', 'chuck']

如果想对一个列表进行完全的copy,就是所有的内容都不改变,那就要使用深copy,即deecopy,使用deecopy要导入copy模块,从结果中可以看出无论后面names的元素怎么更改,names3都保持了原有的元素内容

  1. import copy
  2. names = ["zhangsan","lisi",["zzz","xxx","yyy"],"wangerma","maliang","chuck"]
  3. names3 = copy.deepcopy(names)
  4. names[3] = "hehe"
  5. names[2][2] = "ttt"
  6. print(names)
  7. print(names3)
  8. ['zhangsan', 'lisi', ['zzz', 'xxx', 'ttt'], 'hehe', 'maliang', 'chuck']
  9. ['zhangsan', 'lisi', ['zzz', 'xxx', 'yyy'], 'wangerma', 'maliang', 'chuck']

6.8在列表中使用for循环

  1. names = ["zhangsan","lisi",["zzz","xxx","yyy"],"wangerma","maliang","chuck"]
  2. for i in names:
  3. print(i)
  4. zhangsan
  5. lisi
  6. ['zzz', 'xxx', 'yyy']
  7. wangerma
  8. maliang
  9. chuck

七、元组

元组其实跟列表差不多,也是存一组数,只不是它一旦创建,便不能再修改,所以又叫只读列表;元组中适合存一些不可更改的值,例如存放数据库配置连接内容;元组只有两个方法使用,count和index,原理同列表;使用方法如下

  1. names = ("alex","jack","eric")

八、字典

字典是一种key-value的数据类型,使用就像我们上学用的字典,通过笔划、字母来查对应页的详细内容。

8.1字典的特性

  • 字典是无序的
  • key必须是唯一的
  • 语法:
  1. info = {
  2. 'stu1101': "TengLan Wu",
  3. 'stu1102': "LongZe Luola",
  4. 'stu1103': "XiaoZe Maliya",
  5. }

8.2字典的取值

  • 方法1:通过key直接取值,值存在不报错,值不存在就报错
  1. info = {
  2. 'stu1101': "zhangsan",
  3. 'stu1102': "lisi",
  4. 'stu1103': "wangerma",
  5. }
  6. print(info["stu1101"])
  7. zhangsan
  • 方法2:取值时建议使用get方法,如果想取到的key不存在也不会报错,会返回None
  1. info = {
  2. 'stu1101': "zhangsan",
  3. 'stu1102': "lisi",
  4. 'stu1103': "wangerma",
  5. }
  6. print(info.get("stu1101"))
  7. print(info.get("stu1105"))
  8. zhangsan
  9. None

8.3字典内容的增加

如果数据存在就是修改,不存在就是增加

  1. info = {
  2. 'stu1101': "zhangsan",
  3. 'stu1102': "lisi",
  4. 'stu1103': "wangerma",
  5. }
  6. print(info)
  7. info["stu1104"] = "chuck"
  8. print(info)
  9. {'stu1103': 'wangerma', 'stu1102': 'lisi', 'stu1101': 'zhangsan'}
  10. {'stu1103': 'wangerma', 'stu1104': 'chuck', 'stu1102': 'lisi', 'stu1101': 'zhangsan'}

8.4字典内容的删除

  • 方法1:del指定key
  1. info = {
  2. 'stu1101': "zhangsan",
  3. 'stu1102': "lisi",
  4. 'stu1103': "wangerma",
  5. }
  6. del info['stu1101']
  7. print(info)
  8. {'stu1103': 'wangerma', 'stu1102': 'lisi'}
  • 方法2:pop指定key
  1. info = {
  2. 'stu1101': "zhangsan",
  3. 'stu1102': "lisi",
  4. 'stu1103': "wangerma",
  5. }
  6. info.pop("stu1102")
  7. print(info)
  8. {'stu1103': 'wangerma', 'stu1101': 'zhangsan'}
  • 方法3:popitem,由于字典是无顺序的,所以会随机删除一个,不建议使用
  1. info = {
  2. 'stu1101': "zhangsan",
  3. 'stu1102': "lisi",
  4. 'stu1103': "wangerma",
  5. }
  6. info.popitem()
  7. print(info)
  8. {'stu1103': 'wangerma', 'stu1102': 'lisi'}

8.5判断一个key是否在字典里

  1. info = {
  2. 'stu1101': "zhangsan",
  3. 'stu1102': "lisi",
  4. 'stu1103': "wangerma",
  5. }
  6. print("stu1103" in info) #此方法等同于python2里面的has_key
  7. print("stu1105" in info)
  8. True #存在返回True
  9. False #不存在返回False

8.6多级字典嵌套

  1. av_catalog = {
  2. "欧美":{
  3. "www.youporn.com": ["很多免费的,世界最大的","质量一般"],
  4. "www.pornhub.com": ["很多免费的,也很大","质量比yourporn高点"],
  5. "letmedothistoyou.com": ["多是自拍,高质量图片很多","资源不多,更新慢"],
  6. "x-art.com":["质量很高,真的很高","全部收费,屌比请绕过"]
  7. },
  8. "日韩":{
  9. "tokyo-hot":["质量怎样不清楚,个人已经不喜欢日韩范了","听说是收费的"]
  10. },
  11. "大陆":{
  12. "1024":["全部免费,真好,好人一生平安","服务器在国外,慢"]
  13. }
  • 将大陆的”服务器在国外”改为”在国内做镜像,慢”,一层层改即可,字典字典列表
  1. av_catalog["大陆"]["1024"][1] = "可以在国内做镜像"

8.7打印所有value的值

  1. info = {
  2. 'stu1101': "zhangsan",
  3. 'stu1102': "lisi",
  4. 'stu1103': "wangerma",
  5. }
  6. print(info.values())
  7. dict_values(['zhangsan', 'wangerma', 'lisi'])

8.8使用setdefault在没有此key时创建新的,有此key时不变化

  1. info = {
  2. 'stu1101': "zhangsan",
  3. 'stu1102': "lisi",
  4. 'stu1103': "wangerma",
  5. }
  6. info.setdefault("stu1101","ZHANGSAN")
  7. print(info)
  8. info.setdefault("stu1104","ZHANGSAN")
  9. print(info)
  10. {'stu1102': 'lisi', 'stu1101': 'zhangsan', 'stu1103': 'wangerma'}
  11. {'stu1102': 'lisi', 'stu1104': 'ZHANGSAN', 'stu1101': 'zhangsan', 'stu1103': 'wangerma'}

8.9使用update合并更新key

  1. info = {
  2. 'stu1101': "zhangsan",
  3. 'stu1102': "lisi",
  4. 'stu1103': "wangerma",
  5. }
  6. info2 = {
  7. "stu1102" : "chuck",
  8. "stu1104" : "mario",
  9. "stu1105" : "shuaige"
  10. }
  11. info.update(info2)
  12. print(info)
  13. {'stu1103': 'wangerma', 'stu1101': 'zhangsan', 'stu1102': 'chuck', 'stu1105': 'shuaige', 'stu1104': 'mario'}

8.10使用item将字典转为列表

  1. info = {
  2. 'stu1101': "zhangsan",
  3. 'stu1102': "lisi",
  4. 'stu1103': "wangerma",
  5. }
  6. print(info.items())
  7. dict_items([('stu1101', 'zhangsan'), ('stu1102', 'lisi'), ('stu1103', 'wangerma')])

8.11使用fromkeys创建一个初始化的的字典,创建一层字典的时候没影响,创建多层初始化字典的时候会有影响

  1. temp_dict = dict.fromkeys(["no1","no2","no3"],"test")
  2. print(temp_dict)
  3. {'no1': 'test', 'no3': 'test', 'no2': 'test'}

8.12使用for循环打印字典内容

  • 方法1:此方法高效很多,通过key取出value
  1. info = {
  2. 'stu1101': "zhangsan",
  3. 'stu1102': "lisi",
  4. 'stu1103': "wangerma",
  5. }
  6. for i in info:
  7. print(i,info[i])
  8. stu1102 lisi
  9. stu1103 wangerma
  10. stu1101 zhangsan
  • 方法2:此方法会多次循环,当key很多的时候,效率很低,不建议使用
  1. for k,v in info.items():
  2. print(k,v)
  3. stu1103 wangerma
  4. stu1102 lisi
  5. stu1101 zhangsan

九、查漏补缺只字符串方法

  • 使用capitalize使字符串首字母大写
  1. strings = "chuck"
  2. print(strings.capitalize())
  3. Chuck
  • 使用count统计字母个数
  1. strings = "chuck"
  2. print(strings.count("c"))
  3. 2
  • 使用center来补充空缺,并把str置于中间
  1. strings = "chuck"
  2. print(strings.center(50,"-"))
  3. ----------------------chuck-----------------------
  • 使用endswith判断字符串以什么结尾,可以用判断邮件地址
  1. strings = "chuck"
  2. print(strings.endswith("k"))
  • 使用expandtabs将tab键转换成多少个空格
  1. name = "\t chuck"
  2. print(name.expandtabs(tabsize=30))
  3. chuck
  • 使用find查找字符串的字符索引,并切片
  1. name = " my name is chuck"
  2. print(name.find("is"))

切片

  1. name = " my name is chuck"
  2. print(name[name.find("is"):15])
  3. is chu
  • 使用rfind找到最后边值的下标,忘记他吧
  • 使用format格式化输出
  1. name = " my name is {name}"
  2. print(name.format(name="chuck"))
  3. my name is chuck
  • 使用formt_map格式化输出,以字典传输进去
  1. name = " my name is {name}"
  2. print(name.format_map({'name':"chuck"}))
  3. my name is chuck
  • 使用isalnum判断字符串是否不含有特殊字符却含有数字为True,不包含数字或者含有特殊字符为False
  1. name = "ab123"
  2. print(name.isalnum())
  3. name2 = "abc123#r"
  4. print(name2.isalnum())
  5. True
  6. False
  • 使用isalpha判断字符串是否只包含字母,包括大写
  1. name = "ab123"
  2. print(name.isalpha())
  3. name2 = "abKDFdef"
  4. print(name2.isalpha())
  5. False
  6. True
  • 使用isdecimal判断字符串是否为十进制
  1. name = "77777"
  2. print(name.isdecimal())
  3. name2 ="ad23"
  4. print(name2.isdecimal())
  5. True
  6. False
  • 使用isdigit判断一个字符串是否为整数
  1. name = "77777"
  2. print(name.isdigit())
  3. name2 ="111.111"
  4. print(name2.isdigit())
  5. True
  6. False
  • 使用isidentifier判断字符串是否为合法的标识符,也就是是否为合法的变量名
  1. name = "aaaa77777"
  2. print(name.isidentifier())
  3. name2 = "41232"
  4. print(name2.isidentifier())
  5. True
  6. False
  • 使用isnumeric判断字符串是否为一个数字,很少用
  1. name = "aaaa77777"
  2. print(name.isnumeric())
  3. name2 = "41232"
  4. print(name2.isnumeric())
  5. False
  6. True
  • 使用isspace判断字符串是否是一个空格
  1. name = " "
  2. print(name.isspace())
  3. name2 = "41232"
  4. print(name2.isspace())
  5. True
  6. False
  • 使用istitle判断首字母是否为大写,后面不能是大写
  1. name = "Adjaskdja3234"
  2. print(name.istitle())
  3. name2 = "asdasd1232AADSS"
  4. print(name2.istitle()
  5. True
  6. False
  • 使用isprintable判断是否为可打印
    针对字符串都是可以打印的,只有针对输入设备tty文件才有效,所以这个基本没用,忘记他吧
  • 使用isupper判断字符串是否为大写
  1. name = "Adjaskdja3234"
  2. print(name.isupper())
  3. name2 = "LSAKDLASKDA"
  4. print(name2.isupper())
  5. Fale
  6. True
  • 使用join将列表内容转换成字符串
  1. string = "+"
  2. print(string.join(["1","2","3"]))
  3. 1+2+3
  • 使用ljust在右边补齐
  1. name = "chuck"
  2. print(name.ljust(20,"-"))
  3. chuck---------------
  • 使用rjust在左边补齐
  1. name = "chuck"
  2. print(name.rjust(20,"-"))
  3. ---------------chuck
  • 使用lower将大写变成小写
  1. name = "CHUCK"
  2. print(name.lower())
  3. chuck
  • 使用upper将小写转换为大写
  1. name = "chuck"
  2. print(name.lower())
  3. CHUCK
  • 使用lstrip从左边去掉空格或者回车
  1. name = "\nchuck\n"
  2. print("####")
  3. print(name.lstrip())
  4. print("####")
  5. ####
  6. chuck #左侧回车已去除
  7. 此处为空行 #此处应为空行,markdown不支持空行
  8. ####
  • 使用rstrip从右边去掉空格或者回车
  1. name = "\nchuck\n"
  2. print("####")
  3. print(name.rstrip())
  4. print("####")
  5. ####
  6. 此处为空行 #此处应为空行,markdown不支持空行
  7. chuck #右侧回车已去除
  8. ####
  • 使用strip去掉左右侧空格
  1. name = "\nchuck\n"
  2. print("####")
  3. print(name.rstrip())
  4. print("####")
  5. #### #左侧回车已去除
  6. chuck #右侧回车已去除
  7. ####
  • 使用maketrans将字符串转换成对应的值,结合translate翻译,忘记他吧
  1. p = str.maketrans("asdfg","09876")
  2. print("sdadskjdsdkfjasasdasdasd".translate(p))
  3. 98089kj898k7j09098098098
  • 使用replace替换字符串或者字母,若后面指定数字,表示替换几次,从前到后
  1. name = "chuck is chuck Ma"
  2. print(name.replace("c","C",2))
  3. ChuCk is chuck Ma
  • 使用split将字符串转换成列表,默认为空格,可以指定分隔符
  1. name = "chuck is chuck Ma"
  2. print(name.split())
  3. ['chuck', 'is', 'chuck', 'Ma']
  • 使用splitlines按照换行符(\n)来分割,等同于split(”\n”)
  • 使用swapcase将大小写全部转换
  1. name = "chuck Ma"
  2. print(name.swapcase())
  3. CHUCK mA
  • 使用title将每个字符的首字母变为大写
  1. name = "chuck ma"
  2. print(name.title())
  • 使用zfill在左侧用0补充
  1. name = "chuck ma"
  2. print(name.zfill(20))
0
未经许可,不得转载,否则将受到作者追究,博主联系方式见首页右上角
  • 转载请注明来源:python学习day2
  • 本文永久链接地址:http://www.52devops.com/chuck/730.html

该文章由 发布

这货来去如风,什么鬼都没留下!!!
发表我的评论
取消评论
代码 贴图 加粗 链接 删除线 签到