Python全栈学习入门（二）

Python全栈学习入门（二）代码注释单行注释单行注释只需要在代码前面加上#号多行注释多行注释用三个单引号或者三个双引号躲起来注释内容或者注释内容编写长段的提示信息时，

Python全栈学习入门（二）

代码注释

单行注释

单行注释只需要在代码前面加上#号

多行注释

多行注释用三个单引号或者三个双引号躲起来

"""注释内容"""或者'''注释内容'''

编写长段的提示信息时，可以使用多行注释

代码示例:

docs="""print "I'm a Python developer"print "My blog URL: https://xxxxxxxx.me"print "Life is short, you need Pytho"""""""

字符串数据类型

标准的字符转义码

字符串内建方法

str='人生苦短'print(len(str.encode())) #utf8每个中文占3个字节12print(len(str.encode("gbk"))) #gbk每个中文占2个字节8string.expandtabs(tabsize=8) # tab符号转为空格 #默认8个空格string.endswith(obj,beg=0,end=len(staring)) # 检测字符串是否已obj结束,如果是返回True #如果beg或end指定检测范围是否已obj结束string.count(str,beg=0,end=len(string)) # 检测str在string里出现次数 f.count('\n',0,len(f)) 判断文件行数string.find(str,beg=0,end=len(string)) # 检测str是否包含在string中string.index(str,beg=0,end=len(string)) # 检测str不在string中,会报异常string.isalnum() # 如果string至少有一个字符并且所有字符都是字母或数字则返回Truestring.isalpha() # 如果string至少有一个字符并且所有字符都是字母则返回Truestring.isnumeric() # 如果string只包含数字字符,则返回Truestring.isspace() # 如果string包含空格则返回True string.capitalize() #首字母小写转化为大写string.isupper() # 字符串都是大写返回Truestring.islower() # 字符串都是小写返回Truestring.lower() # 转换字符串中所有大写为小写string.upper() # 转换字符串中所有小写为大写string.strip() #用于移除字符串头尾指定的字符（默认为空格）string.lstrip() # 去掉string左边的空格string.rstrip() # 去掉string字符末尾的空格string.replace(str1,str2,num=string.count(str1)) # 把string中的str1替换成str2,如果num指定,则替换不超过num次string.startswith(obj,beg=0,end=len(string)) # 检测字符串是否以obj开头string.zfill(width) # 返回字符长度为width的字符,原字符串右对齐,前面填充0string.isdigit() # 只包含数字返回Truestring.split("分隔符") # 把string切片成一个列表":".join(string.split()) # 以:作为分隔符,将所有元素合并为一个新的字符string.swapcase() #方法用于对字符串的大小写字母进行转换，将字符串中大写转换为小写、小写转换为大写。

字符串的拼接

bottles=99base=''base +="hujianli staduy python3.6 "base +=str(bottles)base'hujianli staduy python3.699'"hujianli" + " recover" + " 学习python3.6"'hujianli recover 学习python3.6'

使用进行转义

speen = "today we honor our friend, the backslash :\\."print(speen)today we honor our friend, the backslash :\.

字符串格式化(%和format的使用)

#!/usr/bin/env python#-*- coding:utf8 -*-print("I am %s stduy %s" %("hujianli","python"))print("I am {0} stduy {1}".format("hujianli","python") )str = "I am {0} stduy {1}"name = ("hujianli","python")print(str.format(*name))print("%d + %d = %d" % (2,3,2+3))print("%d + %d = %d" % (3,7,3+7))print(" 分割线 ".center(100,"*"))template = '编号:%09d\t 公司名称：%s \t 官网 ：http://www.%s.com'arg1 = (7, "xxx方", "futong")print(template%arg1)template2 = "编号:{:0>9s}\t公司名称：{:s} \t 官网:http://www.{:s}.com "context1 = template2.format("7", "百度", "baidu")print(context1)print("".center(100, "*"))## 打印浮点数number = 123print("%f" % number)print("%.2f" % number)print("%.4f" % number)print()print("{:.2f}".format(number))print("{:+.2f}".format(number))print("圆周率PI 的值为：%.2f" % 3.14)print("圆周率PI 的值为：%10f" % 3.141593) #字段宽度为10print("保留2位小数，圆周率PI 的值为：%10.2f" % 3.141593) #字段宽度为10，字符串占据4个print("保留2位小数， 圆周率PI的值为：%.2f" % 3.141593) #输出，没有字段宽度参数print("字符串精度获取：%.5s " % ('hello world')) #打印字符串前5个字符# 指定占位符宽度print("".center(100, "*"))number = "ABCDE"print("%6s" % number)print("%06s" % number)print("%8s" % number)

代码示例：

#!/usr/bin/env python#-*- coding:utf8 -*-"abc""123abc""abc12*""大家"str2='''This is functionReturn a tuple'''print(str2)print("aaa\nbbb") #换行符print("制表符\t制表符*2") #制表符print("print \r")print("\\显示\\")print("单引号\'")print('双引号\"')print("字符串运算".center(100,"#"))print("aaa" + "bbbb")print("aaa"*3)print("字符串处理函数".center(100,'#'))str3 = "beautiful is batter ugly"print("source string is ",str3)print("字符串大小写互换\n",str3.swapcase())print("字符串转大写\n",str3.upper())print("字符串转小写\n",str3.lower())print("字符串首字母大写\n",str3.title())print("字符串首字母是否大写\n",str3.istitle())print("字符串首字母是否小写\n",str3.islower())print("字符串的第一个字母大写\n",str3.capitalize())print("获得字符串字母u的下标\n",str3.find("u"))print("获得字符串中某一个字母的数量\n",str3.count("u"))print("将字符串转换为列表，以空格分割\n",str3.split(" "))print("以空格拼接字符串")print(" ".join("abcd"))print("计算字符串的长度\n",len(str3))

字符串的修改和替换

代码示例

#!/usr/bin/env python#-*- coding:utf8 -*-s = 'spammy'S = s[:3] + 'xx' + s[5:]print(S)print(s.replace('mm','xx'))hu = 'aa$bb$cc$dd'.replace('$', 'SPAM')print(hu)S = 'xxxxSPAMxxxxSPAMxxxx'where = S.find("SPAM")S = S[:where] + 'EGGS' + S[(where+4):]print(S)S = 'xxxxSPAMxxxxSPAMxxxx'print(S.replace("SPAM","EGGS",1))

字符串格式化输出

代码示例

#!/usr/bin/env python#-*- coding:utf8 -*-print("I am %s stduy %s" %("hujianli","python"))print("I am {0} stduy {1}".format("hujianli","python") )str = "I am {0} stduy {1}"name = ("hujianli","python")print(str.format(*name))print("%d + %d = %d" % (2,3,2+3))print("%d + %d = %d" % (3,7,3+7))print(" 分割线 ".center(100,"*"))template = '编号:%09d\t 公司名称：%s \t 官网 ：http://www.%s.com'arg1 = (7, "xxx方", "futong")print(template%arg1)template2 = "编号:{:0>9s}\t公司名称：{:s} \t 官网:http://www.{:s}.com "context1 = template2.format("7", "百度", "baidu")print(context1)

占位符 说明%s 字符串(采用str()的显示)%r 字符串(采用repr()的显示)%c 单个字符%b 二进制整数%d 十进制整数%i 十进制整数%o 八进制整数%x 十六进制整数%e 指数 (基底写为e)%E 指数 (基底写为E)%f 浮点数%F 浮点数，与上相同%g 指数(e)或浮点数 (根据显示长度)%G 指数(E)或浮点数 (根据显示长度)print("hello,%s" % "world")print('小智今年 %s 岁了' % 18)print('小智今年 %s 岁了' % 19)print('小智今年 %d 岁了' % 20)print("圆周率PI 的值为 %.2f" % 3.14)# 输出类似1.23%这样的结果print("小智的识别能力比去年提高了:%.2f" % 1.25+"%")print("小智的识别能力比去年提高了:%.2f%%" % 1.26 )# 输出百分号print("输出百分号:%s" % "%")# 字符串格式化元组print("今年是%s年，奥运会第%s，中国获得%d枚金牌" % ('2016', '10', 20))# 宽度和精度print("圆周率PI 的值为：%10f" % 3.1415926)print("保留2位小数，圆周率PI 的值为：%10.2f " % 3.1415926)print("字符串精度获取：%.5s" % ("hello world") )print ('从元组中获取字符串精度：%*.*s' % (10,5,'hello world'))print ('从元组中获取字符串精度：%.*s' % (5, 'hello world'))#符号、对齐和0填充print ('圆周率PI 的值为：%010.2f' % 3.141593)#减号（-）用来左对齐数值print ('圆周率PI 的值为：%10.2f' % 3.14)print ('圆周率PI 的值为：%-10.2f' % 3.14)# 加号（+）表示无论是正数还是负数都表示出符号print(('宽度前加加号：%+5d'%10)+'\n'+('宽度前加加号：%+5d'%-10))

示例

In [2]: print("Suzhou is more than %d years. %s lives in here." % (2500, "qiwsir"))Suzhou is more than 2500 years. qiwsir lives in here.

python非常提倡的string.format()的格式化方法，其中{索引值}作为占位符

In [3]: print("my name is {name}, age is {age}".format(name="hujianli",age="22"))my name is hujianli, age is 22In [3]: print("my name is {name}, age is {age}".format(name="hujianli",age="22"))my name is hujianli, age is 22In [6]: str="my name is {0}"In [7]: str.format("hu")Out[7]: 'my name is hu'#字典格式化In [8]: lang = "python"In [10]: print("I LOVE %(program)s" % {'program':lang})I LOVE pythonIn [1]: '{0:!^20s}'.format('BIG SALE')Out[1]: '!!!!!!BIG SALE!!!!!!'

text = "hello world"print(text.ljust(20))print(text.rjust(20))print(text.center(20))print()print("增加填充字段")print()print(text.rjust(20, "-"))print(text.ljust(20, "-"))print(text.center(20, "-"))print()print("format的使用")print()print(format(text, ">20"))print(format(text, "<20"))print(format(text, "^20"))print(format(text, "*>20"))print(format(text, "*<20"))print(format(text, "*^20"))print()print("格式化多个值")print()print("{:>10s} {:>10s}".format("hello", "world"))x = 1.2345print(format(x, ">10"))print(format(x, "^10.2f"))# 使用%进行格式化，较老的格式，不常用print("%-20s" % text)print("%20s" % text)template = "编号， %09d \t公司名称：%s \t官网： http://www.%s.com" # 定义模板print()context1 = (7, "百度", "baidu")context2 = (9, "百度2", "baidu2")print(template % context1)print(template % context2)print()template2 = "编号：{:0>9s}\t公司名称: {:s}\t 官网: http://www.{:s}.com" # 定义模板context01 = template2.format("7", "百度3", "baidu3")context02 = template2.format("8", "百度4", "baidu4")print(context01)print(context02)

字符串的反转

def reverse(s): out = "" li = list(s) for i in range(len(li), 0, -1): out += "".join(li[i - 1]) return outprint(reverse("胡建力啊啊啊啊哈哈哈哈哈"))

使用列表的反转，更简单，如下

def reverse2(s): li = list(s) li.reverse() s = "".join(li) return sprint(reverse2("胡建力啊啊啊啊哈哈哈哈哈"))

一行代码实现字符串的反转

def reverse3(s): return s[::-1]# 或者# 使用lambda来实现lambda_str = lambda s: s[::-1]print(lambda_str("hujianlishuaige"))

列表 List

list() #创建一个空列表[] #创建一个空列表

列表类型内建函数

list.append(obj) # 向列表中添加一个对象objlist.count(obj) # 返回一个对象obj在列表中出现的次数list.extend(seq) # 把序列seq的内容添加到列表中list.index(obj,i=0,j=len(list)) # 返回list[k] == obj 的k值,并且k的范围在i<=kdel

In [16]: maxnum=["hu","jianli","xiaojian","yes"]In [17]: maxnum[-1]Out[17]: 'yes'In [18]: del maxnum[-1]In [19]: maxnumOut[19]: ['hu', 'jianli', 'xiaojian']In [20]: del maxnum[2]In [21]: maxnumOut[21]: ['hu', 'jianli']

in

In [22]: maxnum=["hu","jianli","xiaojian","yes"]In [23]: "hu" in maxnumOut[23]: TrueIn [24]: "hu1" in maxnumOut[24]: False

代码示例1

#!/usr/bin/env python# -*- coding:utf8 -*-lsit1 = ["a", 1, "b", 2.0]print(lsit1[1]) #1print(lsit1[2]) #bprint(lsit1[-2]) #bprint(lsit1[::-1]) # 反转列表 [2.0, 'b', 1, 'a']lsit2 = [3, 4, 5, 6]print(lsit1 + lsit2) #['a', 1, 'b', 2.0, 3, 4, 5, 6]lsit3 = ["python"]print(lsit3 * 3) #['python', 'python', 'python']print("apped()".center(100, "#"))alst = [1, 2, 3, 4, 5]alst.append("hu")print(alst) # [1, 2, 3, 4, 5, 'hu']print("count()".center(100, "#"))print(alst.count(1)) #1print("在列表后追加另一个列表".center(100, "#"))alst.extend(["1", "哈哈"])print(alst) # [1, 2, 3, 4, 5, 'hu', '1', '哈哈']print("查找列表中出现的下标".center(100, "#"))print(alst.index(2)) # 1print("在下标处插入元素".center(100, "#"))alst.insert(2, "hu")print(alst) #[1, 2, 'hu', 3, 4, 5, 'hu', '1', '哈哈']print("返回删除的列表元素，最后一个".center(100, "#"))pop_num = alst.pop()print(pop_num) # 哈哈print(alst) # [1, 2, 'hu', 3, 4, 5, 'hu', '1']print("删除列表的元素2".center(100, "#"))alst.remove(2)print(alst) # [1, 'hu', 3, 4, 5, 'hu', '1']print("反转列表，颠倒".center(100, "#"))alst.reverse()print(alst) # ['1', 'hu', 5, 4, 3, 'hu', 1]alst1 = [6, 2, 3, 4, 5]print("对列表进行排序".center(100, "#"))alst1.sort()print(alst1) #[2, 3, 4, 5, 6]

列表的切片

代码示例2

# 列表元素的个数最多 536870912shoplist = ['apple', 'mango', 'carrot', 'banana']marxes = ['Groucho', 'Chico', 'Harpo', 'Zeppo']others = ['Gummo', 'Karl']marxes.extend(others) #合并列表marxes += others #合并列表shoplist[2] = 'aa'del shoplist[0]shoplist.insert(4,'www')shoplist.append('aaa')############ 列表的切片 ###########shoplist[::-1] # 倒着打印 对字符翻转串有效shoplist[2::3] # 从第二个开始每隔三个打印shoplist[:-1] # 排除最后一个'\t'.join(li) # 将列表转换成字符串 用字表符分割sys.path[1:1]=[5] # 在位置1前面插入列表中一个值list(set(['qwe', 'as', '123', '123'])) # 将列表通过集合去重复{}.fromkeys(l).keys() #列表去重的方法② 通过转换为字典然后在取键eval("['1','a']") # 将字符串当表达式求值,得到列表# enumerate 可得到每个值的对应位置for i, n in enumerate(['a','b','c']): print i,n#与enumerate 方式一样for i in range(len(list)): print(i,list[i])

列表的高级特性

代码示例

#!/usr/bin/env python#-*- coding:utf8 -*-'''import sys #加载sys模块if len(sys.argv) != 2: #判断输入参数是否为2 print("Please supply a filename") raise SystemExit(1)f = open(sys.argv[1]) #命令行上参数1的文件名lines = f.readlines() #将所有行读到一个列表中f.close()#将所有输入值从字符串转换为浮点数fvalues = [float(line) for line in lines]#打印最小值和最大值print("The minimum value is ",min(fvalues))print("The maximum value is ",max(fvalues))'''fruit1 = ['apple','orange']fruit2 = ['pear','grape']fruit1.extend(fruit2)print(fruit1)for i,v in enumerate(fruit1): print(i, v)

列表的查找、排序、反转

代码举例

#!/usr/bin/env python#-*- coding:utf-8 -*-__author__ = '18793'list = ["apple", "banana", "grape", "orange"]print(list.index("apple")) #打印apple的索引print(list.index("orange")) #打印orange的索引print("orange" in list) #判断orange是否在列表中list.sort() #排序print("Sorted list :",list)list.reverse() #反转print("Reversed list:",list)03TrueSorted list : ['apple', 'banana', 'grape', 'orange']Reversed list: ['orange', 'grape', 'banana', 'apple']

元祖 Tuple

tuple()函数创建一个空元祖

元祖和列表类似，区别不可变

代码示例

# 和列表操作很类似，但不可变zoo = ('wolf', 'elephant', 'penguin')# 元祖的小括号并不是必须的，只要将一组数用逗号分隔开来，python就可以认为它是元祖。In [1]: tmp="aa","bb","cc"In [2]: type(tmp)Out[2]: tuple# 元祖使用+号可以组合，类似列表#!/usr/bin/env python#-*- coding:utf8 -*-# auther; 18793# Date：2019/4/15 20:09# filename: 元祖.pyplay1=("梅西","C罗","卡卡西","胡歌")print("原始的元祖：{}".format(play1))play2=play1+("胡建力","小贱","胡小健")print("组合后的元祖：{}".format(play2))# 在元祖添加时，若只有1个元祖，需要在后面加上逗号play3= play2+("路飞",)print("添加元祖，当只有一个元素时，需要在后面加上逗号:{}".format(play3))

元祖

不可变序列（不能添加、修改和删除元素，可以整体替换）支持切片的操作（只能访问元祖中的元素）元祖访问速度快元祖可以作为字典的键

元祖一口气赋值(解包)

In [25]: marx_tuple = ("hu","jian","li")In [27]: a,b,c = marx_tupleIn [28]: aOut[28]: 'hu'In [29]: bOut[29]: 'jian'In [30]: cOut[30]: 'li'可以利用元组在一条语句中对多个变量的值进行交换，而不需要借助临时变量

列表和元祖的区别

可变序列(随时可以添加修改或者删除)支持切片操作（可以访问、修改列表总的元素）列表访问速度慢不能作为字典的键

字典 Dict

dict()函数创建一个空字典，字典是无序的。

字典的内置方法

dict.clear() # 删除字典中所有元素dict.copy() # 返回字典(浅复制)的一个副本dict.fromkeys(seq,val=None) # 创建并返回一个新字典,以seq中的元素做该字典的键,val做该字典中所有键对的初始值dict.get(key,default=None) # 对字典dict中的键key,返回它对应的值value,如果字典中不存在此键,则返回default值dict.has_key(key) # 如果键在字典中存在,则返回True, python3中用in和not in代替了dict.items() # 返回一个包含字典中键、值对元组的列表dict.keys() # 返回一个包含字典中键的列表dict.iter() # 方法iteritems()、iterkeys()、itervalues()与它们对应的非迭代方法一样,不同的是它们返回一个迭代子,而不是一个列表dict.pop(key[,default]) # 和方法get()相似.如果字典中key键存在,删除并返回dict[key]dict.setdefault(key,default=None) # 和set()相似,但如果字典中不存在key键,由dict[key]=default为它赋值dic[key] = [value] #替代了setdefault方法，直接键对应值进行添加字典dict.update(dict2) # 将字典dict2的键值对添加到字典dictdict.values() # 返回一个包含字典中所有值得列表dict([container]) # 创建字典的工厂函数。提供容器类(container),就用其中的条目填充字典len(mapping) # 返回映射的长度(键-值对的个数)hash(obj) # 返回obj哈希值,判断某个对象是否可做一个字典的键del dict["key"] # 删除具有指定键的元素

代码示例1

#!/usr/bin/env python#-*- coding:utf8 -*-ab = { 'Swaroop': 'swaroopch@byteofpython.info','Larry' : 'larry@wall.org'}ab['c'] = 80print(ab)del ab['c']print(ab)li = ["a","b","c"]print(dict(enumerate(li)))#定义字典word = {"che":"车","chen":"陈","cheng":"称","chi":"吃"}print(word)key = ["che","chen","cheng","chi"] #定义索引列表vlaue = ["车", "陈","称","吃"] #定义汉字列表zip1 = dict(zip(key,vlaue)) #将对象转换为字典print(zip1)print(zip1["che"])print(zip1.get("chen")) #键存在，返回值print(zip1.get("chenj")) #键不存在，返回Noneprint(zip1.get("chene","查无此人")) #键不存在，返回默认值dict1 = {}#dict1.fromkeys()name = ["hujianli","jianli","xiaojian","jianlihu"]dictiOnary= dict.fromkeys(name) #创建一个只有键的字典print(dictionary)In [5]: s = dict.fromkeys(("hujianli","xiaojian"),"goodboy")In [6]: sOut[6]: {'hujianli': 'goodboy', 'xiaojian': 'goodboy'}In [7]: s1 = dict.fromkeys((12,23))In [8]: s1Out[8]: {12: None, 23: None}In [9]: s2 = dict.fromkeys(("a","b"))In [10]: s2Out[10]: {'a': None, 'b': None}#del dictionary #删除字典dictionary.clear() #清除字典当中的所有元素，变成一个空字典print(dictionary)#遍历字典的键和值dic2 = {"依梦":"水瓶座","胡建力":"巨蟹座","小健":"狮子座"}"""dic2.items()"""#遍历键和值for key1, vlaue1 in dic2.items(): print(key1,'=====>',vlaue1)#遍历键for key1 in dic2.keys(): print("key is {}".format(key1))#遍历值for vlaue in dic2.values(): print("value is {}".format(vlaue))hu1 = list(zip(['a','b','c'],[1,2,3]))print(hu1)hu2 = dict(zip(['a','b','c'],[1,2,3]))print(hu2)stu1={'学号':'10001','姓名':'张晓光','性别':'男','年龄':20}stu1['年龄']=30print(stu1['性别'])print(stu1)# stu1={'学号':'10001','姓名':'张晓光','姓名':'李三','年龄':20}# print(stu1[1])day={1:'星期一',2:'星期二',3:30,'四':'星期四'}print(day['四'])print(day[2])dict1={'姓名':'张晓光','年龄':20}print('1.所有键：',dict1.keys())print('2.所有值：',dict1.values())print('3.所有键-值：',dict1.items())dict2=dict1dict3=dict1.copy()print('4.浅拷贝和深拷贝：',id(dict1),id(dict2),id(dict3))score1=(1,2,3,4)dict4=dict1.fromkeys(score1)print('5.通过元组创建字典：',dict4)print('6.get年龄：',dict1.get('年龄'))dict1.setdefault('年纪',30)print('7.setdefault年纪：',dict1)dict5={'成绩':'优良'}dict1.update(dict5)print('8.update成绩：',dict1)# 删除字典dict1={'姓名':'张晓光','年龄':20}str1=dict1.pop('姓名')print(str1)print(dict1)dict1={'姓名':'张晓光','年龄':20}if '姓名' in dict1: print(dict1['姓名'])if '性别' not in dict1: dict1.setdefault('性别','男') print(dict1)

添加/修改/删除字典元素

代码示例

#!/usr/bin/env python#-*- coding:utf8 -*-#向字典里面添加元素dict1 = {"1":"hujianli","2":"xiaojian","3":"xiaojian3"}dict1["4"] = "xiaojian4"print(dict1)#修改字典的元素dict1['1'] = "hujianli1"dict1['2'] = "hujianli2"print(dict1)#删除元素del dict1['1']del dict1['2']#进行判断，判断键是否在字典当中if "1" in dict1: del dict1['1']print(dict1)>>> dict.fromkeys(['a', 'b'], 0) {'a': 0, 'b': 0}

字典推导式

#!/usr/bin/env python#-*- coding:utf8 -*-#推导式可以快速生成字典'''{键表达式：值表达式 for 循环}'''import random#生成随机数字典，键为1~4，值为10~100的随机数randomdict = {i: random.randint(10,100) for i in range(1,5)}print(randomdict)name = ["依梦","冷依依","香菱","戴兰"]sign = ["水瓶","射手","双鱼","双子"]dict1 = {i:j for i,j in zip(name,sign)}print(dict1)

字典的重访嵌套

In [17]: rec = {"name":{"first":"Bob","hujianli":"smith","job":["dev","mgr"],"age":"22"}}In [19]: rec["name"]Out[19]: {'age': '22', 'first': 'Bob', 'hujianli': 'smith', 'job': ['dev', 'mgr']}In [20]: rec["name"]["job"]Out[20]: ['dev', 'mgr']In [21]: rec["name"]["job"][1]Out[21]: 'mgr'In [22]: rec["name"]["job"][-1]Out[22]: 'mgr'In [24]: rec["name"]["job"].append("IT")In [25]: recOut[25]:{'name': {'age': '22', 'first': 'Bob', 'hujianli': 'smith', 'job': ['dev', 'mgr', 'IT']}}

字典格式化.py

temp = "书名是：%(name)s,价格是:%(price)010.2f,出版社是:%(publish)s"book1 = {'name': "疯狂python讲义", 'price': 88.9, 'publish': '电子社1'}print(temp % book1)book2 = {'name': "疯狂java讲义", 'price': 78.9, 'publish': '电子社2'}print(temp % book2)

用字典分支构建程序

#!/usr/bin/env python#-*- coding:utf8 -*-import random#定义3个分支函数def print_a(): print("路径分支A")def print_b(): print("路径分支B")def print_c(): print("路径分支C")if __name__ == '__main__': path_dict = {} path_dict['a'] = print_a path_dict['b'] = print_b path_dict['c'] = print_c paths = 'abc' for i in range(4): path = random.choice(paths) print("选择了路径:",path) path_dict[path]()

输出信息

选择了路径: a路径分支A选择了路径: b路径分支B选择了路径: b路径分支B选择了路径: c路径分支C

集合 Set()

set()函数可以将列表转换为集合

可以用于去重复数据

集合的方法

s.update(t) # 用t中的元素修改s,s现在包含s或t的成员 s |= ts.intersection_update(t) # s中的成员是共用属于s和t的元素 s 如果obj不是集合s中的元素(obj not in s),将引发KeyError错误s.discard(obj) # 如果obj是集合s中的元素,从集合s中删除对象objs.pop() # 删除集合s中的任意一个对象,并返回它s.clear() # 删除集合s中的所有元素s.issubset(t) # 如果s是t的子集,则返回True s <= ts.issuperset(t) # 如果t是s的超集,则返回True s >= ts.union(t) # 合并操作;返回一个新集合,该集合是s和t的并集 s | ts.intersection(t) # 交集操作;返回一个新集合,该集合是s和t的交集 s obj是s中的元素 返回Trueobj not in s # 非成员测试:obj不是s中元素 返回Trues == t # 等价测试 是否具有相同元素s != t # 不等价测试s t # 超集测试;s!=t且t中所有元素都是s的成员

交集、并集、差集、对称差集

代码示例1

#集合的创建set1 = {"水瓶座","射手座","双鱼座","双子座"} #定义了一个集合，集合和字典一样，是无序的print(set1) #因为是无序的，所以无法通过索引来获取set2 = {"水瓶座","射手座","双鱼座","双子座","水瓶座"} #去重复了print(set2)python = {"hujianli1","hujianli2","hujianli3","hujianli4","xiaojian1"}C = {"xiaojian1","xiaojian2","xiaojian3","xiaojian4"}print(python | C) #求并集print(python & C) #求交集

代码示例2

#!/usr/bin/env python#-*- coding:utf8 -*-"""交集 &并集 |差集 -"""python = set(["hujianli1","hujianli2",'hujianli3','hujianli4','jianli4'])C = set(['hujianli1','jianli1','jianli2','jianli3','jianli4'])print("选择python学生名字:", python)print("选择C学生的名字:", C)print("交集运算：",python & C) #既选择python语言又选择C语言print("并集运算:",python | C) #参与选课的全部学生名字print("差集运算:",python - C) #python语言和C语言的差集

集合的修改和删除

代码示例3

#!/usr/bin/env python#-*- coding:utf8 -*-mr = set(['零基础学JAVA','零基础学Android',"零基础学PHP",'零基础学C语言']) #定义一个集合mr.add("零基础学python") #向集合当中添加元素，会自动删除重复的元素print(mr)mr.pop() #随机删除元素#print(mr)if "零基础学JAVA" in mr: mr.remove("零基础学JAVA") #移除集合的元素print(mr)mr.clear() #清空整个集合print(mr)# del mr #删除整个集合# print(mr)#-------------------------------------------------# python新增jianli3，C减去jianli3#--------------------------------------------------python = set(["hujianli","xiaojian","xiaojian2","xiaojian3"])C = set(["jianli1","jianli2","jianli3","jianli4"])python.add("jianli3")C.remove("jianli3")print(python)print(C)

不可变集合

student_set = frozenset({"张三", "李四", "王五"})print(student_set)print(type(student_set))#报错，不能被修改# print(student_set.add("胡六"))

列表、元祖、字典、集合的区别

#!/usr/bin/env python#-*- coding:utf8 -*-list = []tuple = ()dict = {}set = set()#是否可变'''列表、字典、集合可变元祖不可变'''#是否重复'''可重复：列表、元祖、字典不可重复：集合'''#是否有序'''列表、元祖 有序字典、集合 无序'''

Python数据类型转换

python中的数据类型有：list、str、tuple、dict、set、float、int

整数、浮点数、字符串之间的转换

代码示例1

#!/usr/bin/env python#-*- coding:utf8 -*-print("int('12.3')",int(12.3))print("int('12.0002')",int(12.0002))print("int('123')",int("123"))print('整数转为浮点数',float(12))print('字符串转换为浮点数',float("123"))print("整数、浮点数转换为字符串".center(100,"#"))print("str('123')",str(123))print("str('123.001')",str(123.001))input_number = input("please input int:")print(input_number)

字符串转列表 /列表转字符串

字符串-->列表 示例

In [1]: hu = "abc"In [2]: list(hu)Out[2]: ['a', 'b', 'c']In [3]: hu = "my name is 123"In [4]: hu.split()Out[4]: ['my', 'name', 'is', '123']

列表-->字符串 示例

In [7]: lst = ["1","2","3","4","hu"]In [8]: ",".join(lst)Out[8]: '1,2,3,4,hu'#引入学习一个内建函数,join()函数是字符串操作函数，用于字符串连接。 拼接字符串有 + 和join两种方式#join有拼接字符串和转列表为字符串的作用和str的spllit()功能反过来In [44]: list1 = ["1","2","3","4"]In [46]: "+".join(list1)Out[46]: '1+2+3+4'#不规则的类别，先转为标准列表，再转为字符串In [13]: hu_list = [1,2,3,4,5,"jianli"]In [14]: hu_list1 = [str(hu) for hu in hu_list ]In [17]: ",".join(hu_list1)Out[17]: '1,2,3,4,5,jianli'

列表转元祖/元祖转列表

In [9]: lstOut[9]: ['1', '2', '3', '4', 'hu']In [10]: tuple(lst)Out[10]: ('1', '2', '3', '4', 'hu')In [11]: hu_tuple = tuple(lst)In [12]: list(hu_tuple)Out[12]: ['1', '2', '3', '4', 'hu']In [14]: a_tuple = ('ready','fire','aim')In [15]: list(a_tuple)Out[15]: ['ready', 'fire', 'aim']

字典格式字符串---> 字典

#方式一#引入学习一个内建函数#eval()函数将字符串当成 Python 表达式来处理In [38]: hu = 1In [39]: eval('hu+1')Out[39]: 2In [23]: s = '{"a": 1, "b": 2, "c": 3}'In [24]: type(s)Out[24]: strIn [25]: d = eval(s)In [26]: type(d)Out[26]: dictIn [27]: dOut[27]: {'a': 1, 'b': 2, 'c': 3}#方式二In [32]: import jsonIn [33]: s = '{"a": 1, "b": 2, "c": 3}'In [34]: type(s)Out[34]: strIn [35]: d = json.loads(s)In [36]: type(d)Out[36]: dictIn [37]: dOut[37]: {'a': 1, 'b': 2, 'c': 3}

二进制bytes与字符串的互转

# bytes转字符串方式一b=b'\xe9\x80\x86\xe7\x81\xab'string=str(b,'utf-8')print(string)# bytes转字符串方式二b=b'\xe9\x80\x86\xe7\x81\xab'string=b.decode() # 第一参数默认utf8，第二参数默认strictprint(string)# bytes转字符串方式三b=b'\xe9\x80\x86\xe7\x81haha\xab'string=b.decode('utf-8','ignore') # 忽略非法字符，用strict会抛出异常print(string)# bytes转字符串方式四b=b'\xe9\x80\x86\xe7\x81haha\xab'string=b.decode('utf-8','replace') # 用？取代非法字符print(string)# 字符串转bytes方式一str1='逆火'b=bytes(str1, encoding='utf-8')print(b)# 字符串转bytes方式二b=str1.encode('utf-8')print(b)

深浅拷贝

这么记忆

浅拷贝：只拷贝顶级的对象，或者说：父级对象深拷贝：拷贝所有对象，顶级对象及其嵌套对象。或者说：父级对象及其子对象

举例说明：

"""深浅拷贝都是对源对象的复制，占用不同的内存空间如果源对象只有一级目录的话，源做任何改动，不影响深浅拷贝对象如果源对象不止一级目录的话，源做任何改动，都要影响浅拷贝，但不影响深拷贝序列对象的切片其实是浅拷贝，即只拷贝顶级的对象"""import copyd = {'name':'hujianli','age':'22'}c1 = copy.copy(d) #浅拷贝c2 = copy.deepcopy(d) #深拷贝print(id(d),id(c1),id(c2)) # 三个不同对象d["name"] = "hujianli"print(d,c1,c2) # 三个不同对象#深拷贝print("深拷贝".center(100,"="))d1 = {'name':{'first':'hu','last':'jianli'}, 'job':['IT','HR']}c1 = copy.copy(d1)c2 = copy.deepcopy(d1)d1["job"][0] = "test"print(d1)print(c1)print(c2)

内置常量与逻辑运算符、比较运算符

内置常量

None 的意义是”无“，常用来表示没有值的对象python中逻辑假包括：False、None、0、空字符串、（）空元祖、[]空列表、和{}空字典，其余的任何值都视为真布尔 Falsenull 类型 None整型 0浮点型 0.0空字符串 ''空列表 []空元组 ()空字典 {}空集合 set()

代码示例

In [2]: if 0: ...: print("None") ...: else: ...: print('True') ...:TrueIn [9]: if {}: ...: print("None") ...: else: ...: print("true") ...:trueIn [12]: if "": ...: print("None") ...: else: ...: print("True") ...:TrueIn [13]: if None: ...: print("None") ...: else: ...: print("True") ...:True

python中的逻辑运算符

or运算符的操作

In [14]: [1,2] or 0 #第一个操作为真，结果为真Out[14]: [1, 2]In [15]: 0 or [1,2] #第一个操作为假，直接返回第二个操作数，即(1,2)，结果为真Out[15]: [1, 2]In [16]: [] or () #第一个操作为假，直接返回第二个操作数，() 空元祖Out[16]: ()

and运算操作符

In [17]: [1,2] and 3 #第一个操作为真，直接返回第二个操作，结果为真Out[17]: 3In [18]: [] and [1,2] #第一个操作为假，直接返回[]，结果为假Out[18]: []In [19]: [] and () # 第一个操作为假，直接返回[]，结果为假Out[19]: []In [20]: 1 and 0 #第一个操作为真，直接返回第二个操作 0 ，结果为假Out[20]: 0In [21]: 0 and True ## 第一个操作为假，直接返回 0 ，结果为假Out[21]: 0

python中的比较运算符

Python 中的比较操作符见下表。相等 ==不等于 !=小于 <不大于 <=大于 >不小于 >=属于 in...

is 和 is not

In [22]: x=3.14In [23]: y=xIn [24]: x is yOut[24]: TrueIn [25]: x is not yOut[25]: FalseIn [27]: x is NoneOut[27]: FalseIn [28]: x = NoneIn [29]: x is NoneOut[29]: True

in 和not in

hujianli = [1,2,3]hujianli2 = ['a', 'b', 'v']In [34]: hujianliOut[34]: [1, 2, 3]In [35]: 1 in hujianliOut[35]: TrueIn [36]: 1 in hujianli2Out[36]: FalseIn [38]: 'a' in hujianli2Out[38]: TrueIn [39]: hujianli3 = {'a':1,'b':2}In [40]: 'a' in hujianli3 #检查'a'是否在字典的键中，返回为True。in只检测字典的键Out[40]: TrueIn [41]: 1 in hujianli3 #值不检测，返回FalseOut[41]: False

赋值运算符

建立大型数据结构

元祖里面嵌套列表

In [31]: list1=["hujianli","leijun","hushiqiang","zhangyong"]In [32]: list2=["wuhan","caidian","xiaogan","yingcheng"]In [33]: list3=["21","22","23","24"]In [34]: tuple_of_list= list1,list2,list3In [35]: tuple_of_list(['hujianli', 'leijun', 'hushiqiang', 'zhangyong'], ['wuhan', 'caidian', 'xiaogan', 'yingcheng'], ['21', '22', '23', '24']) In [36]: tuple_of_list[1]Out[36]: ['wuhan', 'caidian', 'xiaogan', 'yingcheng']In [37]: tuple_of_list[2]Out[37]: ['21', '22', '23', '24']

列表里面嵌套列表

In [40]: list_of_list = [list1,list2,list3]In [41]: list_of_listOut[41]:[['hujianli', 'leijun', 'hushiqiang', 'zhangyong'], ['wuhan', 'caidian', 'xiaogan', 'yingcheng'], ['21', '22', '23', '24']]In [42]: list_of_list[0]Out[42]: ['hujianli', 'leijun', 'hushiqiang', 'zhangyong']In [43]: list_of_list[1]Out[43]: ['wuhan', 'caidian', 'xiaogan', 'yingcheng']

字典里面嵌套列表

In [44]: dict_of_list = { "dict1":list1,"dict2":list2,"dict3":list3 }In [45]: dict_of_list{'dict1': ['hujianli', 'leijun', 'hushiqiang', 'zhangyong'], 'dict2': ['wuhan', 'caidian', 'xiaogan', 'yingcheng'], 'dict3': ['21', '22', '23', '24']}In [47]: dict_of_list.keys()Out[47]: dict_keys(['dict1', 'dict2', 'dict3'])In [48]: dict_of_list.values()Out[48]: dict_values([['hujianli', 'leijun', 'hushiqiang', 'zhangyong'], ['wuhan', 'caidian', 'xiaogan', 'yingcheng'], ['21', '22', '23', '24']])In [49]: dict_of_list.items()Out[49]: dict_items([('dict1', ['hujianli', 'leijun', 'hushiqiang', 'zhangyong']), ('dict2', ['wuhan', 'caidian', 'xiaogan', 'yingcheng']), ('dict3', ['21', '22', '23', '24'])])# 可以一层一层打开里面的内容，使用in进行判断元素。In [59]: for i in dict_of_list.values(): ...: for j in i: ...: if "hujianli" in j: ...: print("找到'hujianli'....") ...: ...:找到'hujianli'....

笔记其实人跟树一样，越是向往高处的阳光，它的根就越要伸向黑暗的地底。