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个字节8 string.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至少有一个字符并且所有字符都是字母或数字则返回True string.isalpha()                              # 如果string至少有一个字符并且所有字符都是字母则返回True string.isnumeric()                            # 如果string只包含数字字符,则返回True string.isspace()                              # 如果string包含空格则返回True string.capitalize()                           #首字母小写转化为大写 string.isupper()                              # 字符串都是大写返回True string.islower()                              # 字符串都是小写返回True string.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的字符,原字符串右对齐,前面填充0 string.isdigit()                              # 只包含数字返回True string.split("分隔符")                        # 把string切片成一个列表 ":".join(string.split())                      # 以:作为分隔符,将所有元素合并为一个新的字符 string.swapcase()                                  #方法用于对字符串的大小写字母进行转换，将字符串中大写转换为小写、小写转换为大写。

字符串的拼接

bottles=99  base=''  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 = 123 print("%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)  #字段宽度为10 print("保留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 function Return 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 22   In [3]: print("my name is {name}, age is {age}".format(name="hujianli",age="22")) my name is hujianli, age is 22   In [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 python  In [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.2345 print(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 out   print(reverse("胡建力啊啊啊啊哈哈哈哈哈"))

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

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

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

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

列表 List

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

列表类型内建函数

list.append(obj)                 # 向列表中添加一个对象obj list.count(obj)                  # 返回一个对象obj在列表中出现的次数 list.extend(seq)                 # 把序列seq的内容添加到列表中 list.index(obj,i=0,j=len(list))  # 返回list[k] == obj 的k值,并且k的范围在i<=k<j;否则异常 list.insert(index.obj)           # 在索引量为index的位置插入对象obj list.pop(index=-1)               # 删除并返回指定位置的对象,默认是最后一个对象 list.remove(obj)                 # 从列表中删除对象obj list.reverse()                   # 原地翻转列表 list.sot(func=None,key=None,reverse=False)  # 以指定的方式排序列表中成员,如果func和key参数指定,则按照指定的方式比较各个元素,如果reverse标志被置为True,则列表以反序排列 list.sort(reverse=True)          #降序

del

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

in

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

代码示例1

#!/usr/bin/env python # -*- coding:utf8 -*- lsit1 = ["a", 1, "b", 2.0] print(lsit1[1])     #1 print(lsit1[2])     #b print(lsit1[-2])    #b print(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))                    #1  print("在列表后追加另一个列表".center(100, "#")) alst.extend(["1", "哈哈"]) print(alst)                         # [1, 2, 3, 4, 5, 'hu', '1', '哈哈'] print("查找列表中出现的下标".center(100, "#")) print(alst.index(2))                    # 1  print("在下标处插入元素".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

# 列表元素的个数最多 536870912 shoplist = ['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)  0 3 True Sorted 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: 元祖.py play1=("梅西","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_tuple  In [28]: a Out[28]: 'hu'  In [29]: b Out[29]: 'jian'  In [30]: c Out[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的键值对添加到字典dict dict.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'] = 80 print(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"))            #键不存在，返回None print(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]: s Out[6]: {'hujianli': 'goodboy', 'xiaojian': 'goodboy'}  In [7]: s1 = dict.fromkeys((12,23)) In [8]: s1 Out[8]: {12: None, 23: None}  In [9]: s2 = dict.fromkeys(("a","b"))  In [10]: s2 Out[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['年龄']=30 print(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=dict1 dict3=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]: rec Out[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 |= t s.intersection_update(t)            # s中的成员是共用属于s和t的元素          s &= t s.difference_update(t)              # s中的成员是属于s但不包含在t中的元素    s -= t s.symmetric_difference_update(t)    # s中的成员更新为那些包含在s或t中,但不是s和t共有的元素  s ^= t s.add(obj)                          # 在集合s中添加对象obj s.remove(obj)                       # 从集合s中删除对象obj;如果obj不是集合s中的元素(obj not in s),将引发KeyError错误 s.discard(obj)                      # 如果obj是集合s中的元素,从集合s中删除对象obj s.pop()                             # 删除集合s中的任意一个对象,并返回它 s.clear()                           # 删除集合s中的所有元素 s.issubset(t)                       # 如果s是t的子集,则返回True   s <= t s.issuperset(t)                     # 如果t是s的超集,则返回True   s >= t s.union(t)                          # 合并操作;返回一个新集合,该集合是s和t的并集   s | t s.intersection(t)                   # 交集操作;返回一个新集合,该集合是s和t的交集   s & t s.difference(t)                     # 返回一个新集合,改集合是s的成员,但不是t的成员  s - t s.symmetric_difference(t)           # 返回一个新集合,该集合是s或t的成员,但不是s和t共有的成员   s ^ t s.copy()                            # 返回一个新集合,它是集合s的浅复制 obj in s                            # 成员测试;obj是s中的元素 返回True obj not in s                        # 非成员测试:obj不是s中元素 返回True s == t                              # 等价测试 是否具有相同元素 s != t                              # 不等价测试 s < t                               # 子集测试;s!=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]: lst Out[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 = 1 In [39]: eval('hu+1') Out[39]: 2  In [23]: s = '{"a": 1, "b": 2, "c": 3}' In [24]: type(s) Out[24]: str  In [25]: d = eval(s) In [26]: type(d) Out[26]: dict In [27]: d Out[27]: {'a': 1, 'b': 2, 'c': 3}  #方式二 In [32]: import json In [33]: s = '{"a": 1, "b": 2, "c": 3}' In [34]: type(s) Out[34]: str  In [35]: d = json.loads(s) In [36]: type(d) Out[36]: dict In [37]: d Out[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，第二参数默认strict print(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 copy d = {'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、空字符串、（）空元祖、[]空列表、和{}空字典，其余的任何值都视为真 布尔             False null 类型        None 整型             0 浮点型           0.0 空字符串         '' 空列表           [] 空元组           () 空字典           {} 空集合           set()

代码示例

In [2]: if 0:    ...:     print("None")    ...: else:    ...:     print('True')    ...: True In [9]: if {}:    ...:     print("None")    ...: else:    ...:     print("true")    ...: true  In [12]: if "":     ...:     print("None")     ...: else:     ...:     print("True")     ...: True  In [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]: 3  In [18]: [] and [1,2]       #第一个操作为假，直接返回[]，结果为假 Out[18]: []  In [19]: [] and ()          # 第一个操作为假，直接返回[]，结果为假 Out[19]: []  In [20]: 1 and 0             #第一个操作为真，直接返回第二个操作 0 ，结果为假 Out[20]: 0  In [21]: 0 and True         ## 第一个操作为假，直接返回 0 ，结果为假 Out[21]: 0

python中的比较运算符

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

is 和 is not

In [22]: x=3.14  In [23]: y=x  In [24]: x is y Out[24]: True  In [25]: x is not y Out[25]: False   In [27]: x is None Out[27]: False  In [28]: x = None  In [29]: x is None Out[29]: True

in 和not in

hujianli = [1,2,3] hujianli2 = ['a', 'b', 'v']  In [34]: hujianli Out[34]: [1, 2, 3]  In [35]: 1 in hujianli Out[35]: True  In [36]: 1 in hujianli2 Out[36]: False    In [38]: 'a' in hujianli2 Out[38]: True  In [39]: hujianli3 = {'a':1,'b':2}  In [40]: 'a' in hujianli3           #检查'a'是否在字典的键中，返回为True。in只检测字典的键 Out[40]: True  In [41]: 1 in  hujianli3            #值不检测，返回False Out[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,list3  In [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_list Out[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'.... 

 一起学习python，一起进步

来源：https://www.cnblogs.com/hujianli/p/11395062.html