1 python数据类型

Python中有六个标准的数据类型：Number(数字)，String(字符串)，List(列表)，Tuple(元组)，Set(集合)，Dictionary(字典)。其中：Number(数字）、String(字符串)、Tuple（元组）是不可变数据，其余三种是可变数据。

转义字符

\n 表示换行
\t 表示制表符
\ 表示\

  1. #转义字符
  2. print ('It\'s a dog!')
  3. print ("hello world!\nhello Python!")#换行
  4. print ('\\\t\\')
  5. print (r'\\\t\\')#使用在引号前加r，原样输出引号内字符串

输出结果

  1. It's a dog!
  2. hello world!
  3. hello Python!
  4. \    \
  5. \\\t\\

布尔值
布尔值是一个逻辑值，只有真(True)和假（False)

  1. e = True
  2. f = False
  3. print(type(e))
  4. print(type(f))
  5. s = 'Python'
  6. print( 'Py' in s)
  7. print( 'py' in s)

输出结果

  1. <class 'bool'>
  2. <class 'bool'>
  3. True
  4. False

2 python数据结构

Python数据结构包括列表(list)、元组(tuple)、集合(set)、字典(dict)等，这里主要讲解列表，列表有两个特点：

  1. 序列中的所有元素都是有自己的编号的——从0开始递增。
  2. 列表是用来存储一连串元素的容器，用中括号[]来表示，列表中元素的类型可不相同。
  1. list = [0, 1, 2, 3, 4, 5]
  2. print (list)
  4. ########索引
  5. ## 注意：索引从0开始，含左不含右
  6. print ('[4]=',list[4])
  7. print ('[-4]=',list[-4])
  8. print ('[0:4]=',list[0:4])
  9. print ('[:4]=',list[:4])#dddd
  10. print( '[4:]=',list[4:])
  11. print ('[0:4:2]=',list[0:4:2])
  12. print ('[-5:-1:]=',list[-5:-1:])
  13. print ('[-2::-1]=',list[-2::-1])

输出结果

  1. [0, 1, 2, 3, 4, 5]
  2. [4]= 4
  3. [-4]= 2
  4. [0:4]= [0, 1, 2, 3]
  5. [:4]= [0, 1, 2, 3]
  6. [4:]= [4, 5]
  7. [0:4:2]= [0, 2]
  8. [-5:-1:]= [1, 2, 3, 4]
  9. [-2::-1]= [4, 3, 2, 1, 0]

修改表中元素

  1. list[3] = "True"
  2. print (list[3])
  3. list[5]="HELLO"
  4. print (list[5])
  5. list[5]=2021
  6. print (list[5])
  7. print (list)

输出结果

  1. True
  2. HELLO
  3. 2021
  4. [0, 1, 2, 'True', 4, 2021]

列表中插入元素

  1. #注意重复运行可在原结果上再次执行命令
  2. list.append('NAME') # 添加到尾部
  3. list.extend(['WAN', 'LI'])#尾部 extend也是添加在尾部
  4. print (list)
  5. age = [90, 80, 75, 66]
  6. list.insert(1, age) # 将[90, 80, 75, 66]添加到第一个元素0后面
  7. list

输出结果

  1. [0, 1, 2, 'True', 4, 2021, 'NAME', 'WAN', 'LI']
  2. [0, [90, 80, 75, 66], 1, 2, 'True', 4, 2021, 'NAME', 'WAN', 'LI']

输出列表中的元素

  1. print (list.pop(1)) # 该函数返回被弹出的元素，不传入参数则默认删除最后一个元素。注意读取顺序0开始
  2. print (list)

输出结果

  1. [90, 80, 75, 66]
  2. [0, 1, 2, 'True', 4, 2021, 'NAME', 'WAN', 'LI']

元素是否在列表元素中及统计个数

  1. print( 'WAN' in list)
  2. print ('WU' not in list)
  3. list.count('WAN')
  4. list

输出结果

  1. True
  2. True
  3. 1

查找某个元素在列表中的位置

  1. ##注意修改后列表中元素变动
  2. print(list)
  3. list.index('LI')

输出结果

  1. [0, 1, 2, 'True', 4, 2021, 'NAME', 'WAN', 'LI']
  2. 8

3 Python控制流

  1. python中有三种控制流类型：顺序结构、分支结构、循环结构。
  2. 在python中通常情况下程序按从上往下的顺序执行语句，而某些时候我们为了改变程序的执行顺序，使用控制流语句控制程序执行方式。
  3. python分隔语句一般用换行来分隔，语块使用Tab键（即空格）缩进而不用大括号。

顺序结构

  1. #按顺序运算
  2. s = '7'
  3. num = int(s) # 一般不使用这种分隔方式
  4. num -= 1 # num = num - 1
  5. num *= 6 # num = num * 6
  6. print (num)

输出结果

  1. 6

if 条件 1

  1. #分支结构
  2. #Python中if语句是用来判断选择执行哪个语句块的
  3. ##条件判断1
  4. a = 1
  5. b = 1.0
  6. if a == b: ###一个等号表示赋值，两个表示判断
  7.     print("you are right!")
  8. else:
  9.     print("you are wrong!")

输出结果

  1. you are right

if 条件 2

  1. #条件判断2(可以多个判断条件elif)
  2. #多个分支
  3. a = 1
  4. if a == 1:  
  5.     print("a = 1")
  6. elif a == 2:
  7.     print("a = 2")
  8. else:
  9.     print("other") #输出a=1 ，如果a不等于那几个就输出other

输出结果

  1. a = 1

循环结构

  1. #for 循环 for (条件变量) in (集合)：
  2. #其中“集合”并不单指set，而是“形似”集合的列表、元组、字典、数组都可以进行循环
  4. names = ["san","si","mazi"]
  5. for name in names:
  6.     print(name)

输出结果

  1. san
  2. si
  3. mazi

循环语句求和

  1. total = 0
  2. for i in range(1, 101):
  3.     total += i #total=total+i
  4. print (total)

输出结果

  1. 5050

4 列表 元组 集合 字典区别和用法

python基础-列表-元组-集合-字典区别和用法 - 图1

4.1 列表

可重复，类型可不同。类型不同也是跟数组最本质的区别。python里的列表用“[]”表示：　
python基础-列表-元组-集合-字典区别和用法 - 图2

  1. names = ["4ZhangYang", "#!Guyun","xXiangPeng","jack","ChenRonghua","XuLiangchen"]
  3. print(names[0])           #  取下标0的值
  4. print(names[-1]) #取最后一个值
  5. print(names[-2:])         #  倒数第二个取到结尾
  6. print(names[1:3])   #取的是下标1和2 的值，取左不取右
  7. print(names[0:-1])         #  从下标0取到倒数第二个
  8. print(names[0:])           #  等价print(names[:])   所有
  9. print(names[0:3])         #  等价print(names[:3])  开始0取到第三个
  10. print(names[0:-1:2]) #   0到-1之间，每隔一个元素，就取一个
  11. print(names[::2])          #  后面的2是表明，每隔一个元素，就取一个

对比a和b的结果

  1. a = [1,2,3]
  2. b = a
  3. a[1] = 555 #下标1是555
  4. b = [1,555,3]
  5. print("list_a = ",a) #lst是用中括号
  6. print("list_b = ",b)
  8. import copy
  9. #names = "ZhangYang Guyun Xiangpeng XuLiangChen"
  10. names = ["4ZhangYang", "#!Guyun","xXiangPeng",["alex","jack"],"ChenRonghua","XuLiangchen"] #可以列表套列表
  11. name2 = copy.deepcopy(names)   # 深度copy，彻底的把names 复制给name2,修改names对name2无影响。
  12. #name2 = names.copy()          # 浅浅copy，只copy第一层，修改names 的第二层元素值，会影响name2 的第二层的值
  13. #name2 = names                 # 直接复制，修改names，就会影响name2，指向的同一块地址。
  14. print(names)
  15. print(name2)
  16. names[2] = "向鹏"
  17. names[3][0] ="ALEXANDER"        # 下标3 也是一个list，取下标3的第0个下标
  18. print(names)
  19. print(name2)

列表的 —- 增 — 删 — 改 — 查

  1. # 列表的 ---  增 -- 删 -- 改 -- 查
  2. names = ["4ZhangYang", "#!Guyun","xXiangPeng",["alex","jack"],"ChenRonghua","XuLiangchen"]
  3. names.append("LeiHaidong") #在最后面添加
  4. names.insert(1,"ChenRonghua") #在下标1后面插入
  5. names[2] ="XieDi" #修改下标2的值
  7. #delete
  8. names.remove("ChenRonghua") #如果存在多个重复，只删除第一个重复值
  9. del names[1]                             # 等价 names.pop(1) 删除下标1的值
  10. del names                                #删除names， 就是不存在了，若是在使用print(names)打印就会报错
  11. print(names)
  12. print(names.index("XieDi")) #显示XieDi的下标索引
  13. print(   names[names.index("XieDi")]   )#显示显示XieDi的下标索引的值XieDi
  15. print(names.count("ChenRonghua")) #计数个数
  16. names.clear()                            # 清空names里面的元素，注意区别和del names 的区别,但列表仍然存在
  17. names.reverse() #反向列表中元素。
  19. a=[1,23]
  20. #list.sort(cmp=None, key=None, reverse=False) 默认是false升序
  21. a.sort() #sort进行排序必须是整数才可以，要不然会报错。
  22. a
  24. names2 = [1,2,3,4]
  25. #list.extend(seq) seq是元素列表，在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）.
  26. names.extend(names2)
  27. names

循环输出列表内容，在结尾添加指定的内容

  1. #循环输出列表内容，在结尾添加指定的内容
  2. names2 = [1,2,3,4]
  3. for x in names2:
  4.  print(x,"\n")
  5. print("\n")
  6. for x in [1, 2, 3]:
  7.  print(x, end="1")  #  输出的内容结尾添加1

4.2 字符串

字符串是 Python 中最常用的数据类型。我们可以使用引号(‘或”)来创建字符串。

  1. name = "WOSHISHUI"
  2. name.capitalize()           # 首字母大写,其它字母所有变小写
  3. name.casefold()             # 大写所有变小写
  4. name.center(20,"-")         # 输出 '-----WOSHISHUI------'，将字符串放在中间
  5. name.count('SHI')           # 统计 SHI出现次数
  6. name.encode()               # 将字符串编码成bytes格式
  7. name.endswith("Li")         # 判断字符串是否以 Li结尾，返回布尔值
  8. print("woshi\tshui".expandtabs(10))     # 输出'woshi      shui'， 将\t转换成多长的空格
  9. print(name.find('A'))                   # 查找A,找到返回其索引， 找不到返回-1

4.3 元组

元组与列表相似，不一样之处在于元组的元素不能修改。
元组使用小括号，列表使用方括号。
元组建立很简单，只须要在括号中添加元素，并使用逗号隔开便可。

  1. tup1 = ("Google", "Runoob", 1997, 2000)
  2. tup2 = (1, 2, 3, 4, 5, 6, 7)
  3. print("tup1[0]: ", tup1[0])
  4. print("tup2[1:5]: ", tup2[1:5])
  6. # 如下修改元组元素操做是非法的。
  7. #tup1[0] = 100
  8. # 报错：TypeError: 'tuple' object does not support item assignment
  11. # 建立一个新的元组
  12. tup3 = tup1 + tup2;
  13. print(tup3)
  14. print(len(tup3))    # 输出元组元素个数
  16. #删除元组 - 不能删除指定的下标，只能整个删除
  17. del tup1
  19. #------- 元素函数 -----------------
  20. tuple1 = ('Google', 'Runoob', 'Taobao')        # 计算元组元素个数。
  21. print(len(tuple1))
  23. tuple1 = ('5', '4', '9')                        # 返回元组中元素最大值。
  24. print(max(tuple1))
  26. tuple1 = ('5', '4', '9')                        # 返回元组中元素最小值。
  27. print(min(tuple1))
  29. list1= ['Google', 'Taobao', 'Runoob', 'Baidu']  # 将列表转换为元组。
  30. tuple1=tuple(list1)
  31. print(tuple1)

4.4 字典

字典是另外一种可变容器模型，且可存储任意类型对象。
字典的每一个键值(key=>value)对用冒号(:)分割，每一个对之间用逗号(,)分割，整个字典包括在花括号({})中 ,格式以下所示：
d = {key1 : value1, key2 : value2 }

  1. dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
  2. print("dict['Name']: ", dict['Name']) #就是直接取值
  3. print("dict['Age']: ", dict['Age'])
  5. #------ 修改字典元素
  6. dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
  7. dict['Name'] = "test"  # 添加信息
  8. dict['Age'] = 8  # 更新 Age
  10. print("dict['Name']: ", dict['Name'])
  11. print("dict['Age']: ", dict['Age'])
  14. # ----- 删除字典元素
  15. dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
  17. del dict['Name']  # 删除键 'Name'
  18. print(dict)
  20. dict.clear()  # 清空字典
  21. print(dict)
  22. del dict  # 删除字典
  23. print(dict["Name"]) #会报错，因为已经删除

字典函数

  1. dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
  2. print(len(dict))   #计算字典元素个数，即键的总数。
  3. print(str(dict))   #输出字典，以可打印的字符串表示。
  4. print(dict) #和上述str(dict)一样
  5. type(dict)  #返回输入的变量类型，若是变量是字典就返回字典类型。
  8. 1 radiansdict.clear()
  9. 删除字典内全部元素
  10. 2  radiansdict.copy()
  11. 返回一个字典的浅复制
  12. 3  radiansdict.fromkeys()
  13. 建立一个新字典，以序列seq中元素作字典的键，val为字典全部键对应的初始值
  14. 4  radiansdict.get(key, default=None)
  15. 返回指定键的值，若是值不在字典中返回default值
  16. 5  key in dict
  17. 若是键在字典dict里返回true，不然返回false
  18. 6  radiansdict.items()
  19. 以列表返回可遍历的(键, 值) 元组数组
  20. 7  radiansdict.keys()
  21. 返回一个迭代器，可使用 list() 来转换为列表
  22. 8  radiansdict.setdefault(key, default=None)
  23. 和get()相似, 但若是键不存在于字典中，将会添加键并将值设为default
  24. 9  radiansdict.update(dict2)
  25. 把字典dict2的键/值对更新到dict里
  26. 10 radiansdict.values()
  27. 返回一个迭代器，可使用 list() 来转换为列表
  28. 11 pop(key[,default])
  29. 删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 不然，返回default值。
  30. 12 popitem()
  31. 随机返回并删除字典中的最后一对键和值。

4.5 集合

集合（set）是一个无序的不重复元素序列。
可使用大括号 { } 或者 set() 函数建立集合，注意：建立一个空集合必须用 set() 而不是 { }，由于 { } 是用来建立一个空字典。
它的主要做用以下： 1.去重，把一个列表变成集合，就自动去重了。2.关系测试，测试两组数据以前的交集、差集、并集等关系。

  1. basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
  2. print(basket)  ##这里演示的是去重功能,只会输出没有重复的元素
  3. print("orange" in basket) # 判断元素是否在集合内 返回true 、 false
  6. #s = set([3,5,9,10])  # 建立一个数值集合
  7. #s = set((3,5,9,10))  # 建立一个数值集合
  8. s = set({3,5,9,10})  # 建立一个数值集合 用（），[],{}建立集合都可以
  9. print(s)
  10. type(s)
  13. t = set("Hello")  # 建立一个唯一字符的集合
  14. print(t) #这里就会去重，剩下一个l
  15. print(type(t))
  17. t=set(['HELLO','12',1])  #如果是这样就会把hello当成一个元素来看
  18. t

关系测试

  1. t = set("Hello")
  2. s = set({3,5,9,10}) 
  3. a = t | s  # t 和 s的并集
  4. print("a = ",a)
  5. b = t & s  # t 和 s的交集
  6. print("b = ",b)
  7. c = t - s  # 求差集（项在t中，但不在s中）
  8. print("c = ",c)
  9. d = t ^ s  # 对称差集（项在t或s中，但不会同时出现两者中）
  10. print("d = ",d)

输出结果

  1. a =  {3, 5, 'l', 9, 'e', 10, 'H', 'o'}
  2. b =  set()
  3. c =  {'e', 'H', 'o', 'l'}
  4. d =  {3, 5, 'l', 9, 10, 'e', 'H', 'o'}

元素的添加和删除

  1. s.add(1)               # 添加一个元素
  2. print(s)
  3. s.update([1,2,'3xx'])  # 添加多个元素
  4. print(s)
  5. #s.remove("10sdsd")     # 移除一个元素,不存在会发生报错
  6. #print(s)
  7. s.pop()                # 随机 移除一个元素
  8. print(s)
  9. print(len(s))                 # 输出 集合元素个数
  10. s.clear()               # 清空
  11. print(s)
  13. print( "x" in s)         # 查找x 是否在s 集合里面,存在返回ture
  14. print( "x" not in s)     # 查找x 不在s 集合里面,不在返回true