Python保姆级教程 数据类型—新手小白入门必看系列

保起

推荐使用压缩软件和杀毒软件
7 - zip
使用火绒
一、基本数据类型与变量（上）

2.1 注释

优点：

• 代码说明
  

没注释的代码
有注释的代码

• 不让解释器执行注释的那句话
  

2.2 单行注释

单行注释快捷键：ctrl + ？
2.3多行注释

""""""  （三个双引号）
2.4 字面量变量

1. 字面量是已经被定义好的量
2. 在程序中可以直接使用的字面量：1,2,3,4,5,6

复制代码

185730213551
什么是变量：可以改变的量
计算机用来存贮数据的盒子，想用这个数据，就直接那盒子就好了

1. 变量名 = 值
3. a = 10
4. print(a)
6. 10

复制代码

不要把赋值语句的等号等同于数学的等号：

1. x = 10
2. x = x +2

复制代码

1. a = 'abc'
2. b = a
3. a = 'edg'
4. print(b)
6. abc

复制代码

说明：

1. 1.变量就是可以变化的量，可以随时进行修改
2. 2.程序是使用来处理数据的，而变量就是用来存贮数据的
3. 3.变量就是一个存贮数据时，当前数据所在的内存地址的名字

复制代码

多个变量赋值

1. a, b, c = 1, 2, 'd'
2. print(a)
3. print(b)
4. print(c)
6. 1
7. 2
8. d
10. a = b = c = 1
11. print(a)
12. print(b)
13. print(c)
15. 1
16. 1
17. 1

复制代码

2.5 标识符和关键字

规则如下：

• 由数字，字母，下划线组成
  
• 不能以数字开头
  
• 不能使用内置的关键字
  
• 严格区分大小写
  

2.6命名规范

• 标识符命名要做到见名知意
  

name ，age ，
遵守命名规范

• 驼峰命名法：大驼峰和小驼峰命名法
  
• 大驼峰：每一个单词的首字母都采用大写字母
  

First Name，  Last Name

• 小驼峰：第一个单词以小字母开始；第二个单词的首写字母大写
  

myName ， youName
2.7关键字

具有特殊功能的的标识符，就是关键字
关键字不能声明为变量名

1. #打印python的所有关键字
2. import keyword
3. print(keyword.kwlist)
5. ['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

复制代码

2.8 基本数据类型初始

数值类型
2.8.1 整数类型 int

1 ，2 ，3， 100， 200， -300， 0

1. n = 78
2. print(n)
4. 78
6. a = 1000_0000_0000_0000
7. b = 1000000000000000
8. print(a)
9. print(b)
11. 1000000000000000
12. 1000000000000000

复制代码

2.8.2 浮点类型 float

1.23×10^9
12.3×10^8
1.23 , 3.14, -9.1
1.23e9， 12.3e8， 0.000012==》1.2e-5
rount
两种方式表示浮点数

• 十进制形式 ，1.2 ， 1.23 ， 12.3
  
• 指数形式 （科学计数法）
  

1. aen 或者 aEn
2. a为尾数部分，n是指数部分，E或e是固定的字符，用于分割尾数部分和指数部分
3. 2.1e5 = 2.1×10^5 其中2.1是尾数，5是指数
4. 3.7E-2 = 3.7×10^-2 其中3.7是尾数，-2是指数
5. 0.5E7 = 0.5×10^7 其中0.5是尾数， 7是指数
6. 14E3 = 14×10^3  其中14是尾数，3是指数
8. print(14E3)
10. float1 = 0.0000000000000000000847
11. print(float1)
13. 14000.0
14. 8.47e-20

复制代码

2.8.3 布尔值 bool

只有True 和False 两种值，注意大小写
True 表示真(表示条件满足或者成立) ==》1
False 表示假(表示条件不满足或者不成立) == 》0

1. print(3>2)
2. print(2>3)
4. True
5. False

复制代码

2.8.4 字符串 str

不属于数值类型，它是序列类型
以单引号，双引号，三引号括起来的任意文本，abc ， xyz
基本使用

1. name = 'python'
2. age = 18
3. jiaxiang = '湖北'
4. print(name+jiaxiang)  # 相加就是简单的字符串拼接
5. print(name*5) # 相乘就相当于将字符串和自己相加了5次
7. python湖北
8. pythonpythonpythonpythonpython

复制代码

两种取值顺序：

• 从左到右索引默认0开始，最大范围是字符串长度少1
  
• 从右往左索引默认-1开始，最大范围是字符串的开头
  

1. str3 = 'abcdefg'
2. print(str3[2])
3. print(str3[6])
4. print(str3[-1])
6. c
7. g
8. g
10. 子字符串[初始位置:结束位置]，包头不包尾 ，左闭右开
11. str3 = 'abcdefg'
12. print(str3[1:6])
13. print(str3[:6])
14. print(str3[3:])
16. bcdef
17. abcdef
18. defg

复制代码

2.9 查看数据类型

• 变量没有类型，数据才有类型
  

type(变量的名字)==》查看数据类型

1. a = 'ab'
2. b = 123
3. c = 1.23
5. print(type(a))
6. print(type(b))
7. print(type(c))
9. <class 'str'>
10. <class 'int'>
11. <class 'float'>

复制代码

2.9.1 转义字符  \

\n ==》 换行
\t ==》 制表符， 一个tab键，也就是四个空格
\ \ ==》\
转义符 必须写在引号内，转义就是把他变蠢了

1. print('床前明月光,\n疑是地上霜')
2. print('床前明月光,\t疑是地上霜')
4. 床前明月光,
5. 疑是地上霜
6. 床前明月光,        疑是地上霜
8. print('\\\n\\')
10. \
11. \

复制代码

1. height = 175.0
2. print('您的身高是：'+height) # 报错
3. print('您的身高是：'+str(height))
5. i = int('123')
6. print(i)
7. ii = ('123个')
8. print(ii)
11. 您的身高是：175.0
12. 123
13. 123个

复制代码

看到这里给大家留一个彩蛋，初学作业

1. 1.用变量给自己建立个角色信息，要输出出来
2.     姓名
3.     年龄
4.     身高
5.     家乡
6.     兴趣
7.     是否有编程基础
8. 2.有一个字符串变量  s = '人生苦短，我学python'
9.     通过下标索引，分别输出 苦，学 o 这几个字符

复制代码

二、数据类型（下）

1.1 列表生成式

1. list [1,2,3,4,5,6,7,8,9]
3. list1 = [1,2,3,4,5,6,7,8,9]
4. print(list1)
5. [1, 2, 3, 4, 5, 6, 7, 8, 9]
7. print(list(range(1,10)))
8. [1, 2, 3, 4, 5, 6, 7, 8, 9]

复制代码

1.1.1 普通的列表生成式

1. # 普通写法
2. li = []
3. for i in range(1,10):
4.     li.append(i)
5. print(li)
7. # 列表生成式写法
8. print([i for i in range(1,10)])

复制代码

1. [1*1,2*2,3*3,4*4,...,9*9]
2. # 普通写法
3. li = []
4. for i in range(1,10):
5.     li.append(i*i)
6. print(li)
8. # 列表生成式
9. print([i*i for i in range(1,10)])

复制代码

1. [1*2,2*3,3*4,...,9*10]
2. # 普通写法
3. li = []
4. for i in range(1,10):
5.     li.append(i*(i+1))
6. print(li)
8. # 列表生成式
9. print([i*(i+1) for i in range(1,10)])
11. [2, 6, 12, 20, 30, 42, 56, 72, 90]
12. [2, 6, 12, 20, 30, 42, 56, 72, 90]

复制代码

1. # 求偶数 ，普通写法
2. li = []
3. for i in range(1,11):
4.     if i % 2 == 0:
5.         li.append(i)
6. print(li)
8. # 带if的列表生成式
9. print([i for i in range(1,11) if i % 2 == 0])
11. [2, 4, 6, 8, 10]
12. [2, 4, 6, 8, 10]

复制代码

使用两层循环，生成一切组合可能（ABC和123）

1. # 普通写法
2. li = []
3. for i in 'ABC':
4.     for j in '123':
5.         li.append(i+j)
6. print(li)
8. # 双层循环写法
9. print([i+j for i in 'ABC' for j in  '123'])
11. ['A1', 'A2', 'A3', 'B1', 'B2', 'B3', 'C1', 'C2', 'C3']
12. ['A1', 'A2', 'A3', 'B1', 'B2', 'B3', 'C1', 'C2', 'C3']

复制代码

1.2 元组 tuple

元组通常使用一对小括号将所有元素包围起来，但是小括号不是必须的

1. tuple1 = 'python教程', 'Java'
2. print(tuple1)
3. print(type(tuple1))

复制代码

1.2.1 查

1. count()
2. tuple2 = (123, 'Google', 'JD', 'Taobao', 123)
3. print(tuple2.count(123))  # 2
4. print(tuple2.count('JD'))
6. 2
7. 1
8. index()
9. 检索某个元素的下标值
10. t = (123, 'Google', 'JD', 'Taobao', 123)
11. print(t.index(123))
12. print(t.index(123,1))
14. 0
15. 4

复制代码

1.2.2 功能

1. 1相加，两个元组相加生成一个新的元组
2. data = ('张三', '李四') + ('王五', '赵六')
3. print(data)
4. ('张三', '李四', '王五', '赵六')
6. 2.相乘
7. data = ('张三', '李四')*2
8. print(data)
9. ('张三', '李四', '张三', '李四')
11. 3.获取长度
12. data = ('张三', '李四')
13. print(len(data))
14. 2
15. 4.索引
16. data = ('张三', '李四', '王五', '赵六')
17. print(data[0])
18. print(data[1])
19. print(data[2])
20. print(data[3])
22. 张三
23. 李四
24. 王五
25. 赵六
27. 5.切片
28. data = ('张三', '李四', '王五', '赵六')
29. print(data[0:3])
30. ('张三', '李四', '王五')
32. 6.步长，隔多少取值
33. data = ('张三', '李四', '王五', '赵六')
34. print(data[1:4:2]) # 1是开始位置，4是结束位置，2是步长
35. ('李四', '赵六')
37. 7.for循环
38. data = ('张三', '李四', '王五', '赵六')
39. for i in data:
40.     if i == '李四':
41.         continue  # 结束本次循环 ，继续执行下一次循环
42.     print(i)
43.    
44. 张三
45. 王五
46. 赵六

复制代码

元组的本身是不可变的，如果元组中包含其他可变元素，这些可变元素就可以改变
1.3字符串格式化输出

1. 你好某某某 我叫某某某 再见某某某
2. name = 'python'
3. age = 18
4. print('大家好, 我叫'+name+', 我今年'+str(age)+'岁')

复制代码

1.3.1% 方法（占位符）

1. %s = 字符串 ==》只能放在字符串里面
2. %d = 整数 ==》 只能放整数
3. %f = 小数 ==》默认保留六位小数
4.         %.1f ==> 保留一位小数
5.     %.2f ==> 保留两位小数

复制代码

1. 语法：（'xx%dxxx%s'%(变量1，变量2)）# 或者带入变量数据
2. name = 'python'
3. age = 18
4. height = 175.0
5. print('你好，我叫%s， 今年%d岁了， 身高%f'%(name,age,height))
6. print('你好，我叫%s， 今年%d岁了， 身高%.1f'%(name,age,height))
7. print('你好，我叫%s， 今年%d岁了， 身高%.2f'%(name,age,height))
9. 你好，我叫python， 今年18岁了， 身高175.000000
10. 你好，我叫python， 今年18岁了， 身高175.0
11. 你好，我叫python， 今年18岁了， 身高175.00
13. s = '我叫%s, 今年%d岁了, 身高%f'
14. print(s%('python', 15, 175.0))
16. 我叫python, 今年15岁了, 身高175.000000

复制代码

1.3.2 format()

1. 语法:
2. name = 'python'
3. age = 18
4. height = 175.0
5. print('你好， 我叫{}，今年{}岁了，身高{}'.format(name,age,height))
7. 传入的数据类型是不限的，字符串，元组，列表都行
8. 数据跟{}顺序从左到右一一对应
9. 直接传数据
10. 传入多个数据：
11. '{}{}{}'.format（数据1，数据2，数据3）
12. print('你好，我叫{}，今年{}岁了，身高{}'.format('python',18,175.0))
13. 自定义数据：
14. '{下标}{下标}'.format(数据1，数据2)
15. print('你好，我叫{0}，今年{2}岁了，身高{1}'.format('python',175.0,18))

复制代码

1.3.3 f-format

1. 语法：在字符串里面加上一个f/F，把要输出的变量用大括号{}包裹
2. name = 'python'
3. age = 18
4. height = 175.0
5. print(f'大家好，我叫{name},我今年{age}岁了，身高是{height}')
6. print(f'大家好，我叫{name[0]},我今年{age+1}岁了，身高是{height-10}')
8. 大家好，我叫python,我今年18岁了，身高是175.0
9. 大家好，我叫p,我今年19岁了，身高是165.0

复制代码

三 数据类型进阶（上）

2.1散列类型

1.数据类型：int , float , bool ==>存储一个数值
2.序列类型： str， list ， tuple ==》存储多个数据
3.散列类型
无序 内部元素不重复 没有下标
2.1.1字典 dict

用来保存一些有典型的对应关系的数据类型，特点是使用键值对的方式来存储数据
key === >  键    value===> 值
键值对的语法：key：value
表现形式：
{}，不过大括号里面如果存储的是键值对，那么就是字典
通过键查找值
字典名[键]
字典的key不可以是重复的，如果重复则取最后一个重复键的值

1. call = {'python':'11234', 'look':'11235', '阿尔法':'11236'}
2. user = {'姓名':'python', '年龄':18, '工作':'python讲师'}
4. print(call['python'])
5. print(user['工作'])
7. dict1 = {'a':1, 'b':2, 'a':3, 'a':4}
8. print(dict1)
10. 11234
11. python讲师
12. {'a': 4, 'b': 2}

复制代码

可变性

1. dict1 = {'a':1, 'b':2, 'a':3, 'a':4}
2. dict1['b'] = 100
3. print(dict1)
4. {'a': 4, 'b': 100}

复制代码

当我们想要表示一组固定信息的时候，用字典就可以更加的直观

1. 字典包含多个键值对，key是字典的关键数据，程序对字典的操作都是基于key的
2. - 通过key访问value
3. - 通过key添加key-value对
4. - 通过key删除key-value对
5. - 通过key修改key-value对
6. - 通过key判断指定key-value对是否存在

复制代码

1. 通过key访问value
2. scores = {'语文':89}
3. print(scores['语文'])
5. 如果腰围字典添加key-value对，就只需要为不存的key赋值就可以了
6. scores['数学'] = 93
7. scores[92] = 8.4
8. print(scores)
10. 如果要删除字典中的键值对，就可以使用del语句
11. del scores['语文']
12. del scores['数学']
13. print(scores)
15. 对存在的键值对赋值，新的值会覆盖原来的值
16. cars = {'bmw':88, 'benchi':83, 'tesila':95}
17. cars['benchi'] = 4.3
18. cars['tesila'] = 3.8
19. print(cars)
21. 判断字典是否包含指定的key，使用in或者not in
22. in  not in # in 包含   not in 不包含
23. cars = {'bmw':88, 'benchi':83, 'tesila':95}
24. print('tesila' in cars)
25. print('baoshijie' in cars)
26. print('BYD' not in cars)

复制代码

字典的key可以是任意的不可变类型
字典允许直接对不存在的key赋值，这样就可以增加一个键值对
常用方法

1. 字典方法
2. print(dir(dict))
4. ['__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__',
7. 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']

复制代码

2.1.1.1 clear（）

用于清空点中所有的键值对

1. cars = {'bmw':88, 'benchi':83, 'tesila':95}
2. print(cars)
3. cars.clear()
4. print(cars)
6. {'bmw': 88, 'benchi': 83, 'tesila': 95}
7. {}

复制代码

2.1.1.2 get()

根据key获取value的

1. cars = {'bmw':88, 'benchi':83, 'tesila':95}
2. print(cars.get('bmw'))
3. print(cars.get('baoshijie'))
4. print(cars['baoshijie'])
6. 88
7. None
8.     print(cars['baoshijie']) # 报错
9. KeyError: 'baoshijie'

复制代码

翻车的地方 （元组）
data = (99,88,77,['左手',18],33,22,11)
data[3]  [0] = 'look'
print(data)
元素不可变 但是元素内部有可变的类型 就可以改变 但只限于元组内部 可变元素
彩蛋

1. # 1.将列表数据[1,2,3,2,1,4,4,4,2,5,6,7,7,9,8,10,10]去重
3. # 2.有字典 dic = {"k1":"v1"，"k2":"v2"，"k3":"v3"}，实现以下功能:
4. (1)、遍历字典 dic 中所有的key
5. (2)、遍历字典 dic 中所有的value
6. (3)、循环遍历字典 dic中所有的key和value
7. (4)、添加一个键值对"k4"，"v4",输出添加后的字典 dic
8. (5)、删除字典 dic 中的键值对"k1" "v1",并输出删除后的字典 dic
9. (6) 获取字典 dic中“k2"对应的值
10. # 3.students =[
11. {'name':'go','age':18,'score':98,'tel':'18888888888', gender':'female'},
12. {'name''Java'age :20 'score':95."tel’: 18888888889' 'aender'.'unkown'}，
13. {'name':'python' 'age' 18 'score':88.'tel':'18888888810' 'gender':'male'}，
14. {'name':'php','age':16,'score':58,'tel':'18888888811', 'gender':'unkown'},
15. {'name':'c' 'age':19.'score':78.'tel':'18888888812' 'gender': male'}，
16. {'name':'c++' 'age':17.'score':92,'tel':'18888888813','gender':'male'},
17. ]
19. #(1)统计及格学生的个数
20. #(2)打印不及格学生的名字和对应的成绩
21. # #(3)删除性别不明的所有的学生

复制代码

四、数据类型进阶（中）

1.1 update()

可以使用一个字典所包含的键值对来更新已经有的字典，如果被更新的字典包含对应的键值对，那么原来的值会被覆盖，如果不包含，就会被添加进去

1. cars = {'bmw':88, 'benchi':83,'tesila':95}
2. cars.update({'bmw':4.5,'baoshijie':9.3})
3. print(cars)
4. {'bmw': 4.5, 'benchi': 83, 'tesila': 95, 'baoshijie': 9.3}

复制代码

1.2 items(), keys(), values()

dict_items,dict_keys,dict_values对象，python不希望用户直接操作这几个方法，但是可以通过list（）函数把他们转成列表

1. items（）==》取键值对
2. cars = {'bmw':88, 'benchi':83,'tesila':95}
3. ims = cars.items()
4. print(ims)
5. print(type(ims))
6. print(list(ims))
7. print(list(ims)[1])
9. dict_items([('bmw', 88), ('benchi', 83), ('tesila', 95)])
10. <class 'dict_items'>
11. [('bmw', 88), ('benchi', 83), ('tesila', 95)]
12. ('benchi', 83)
14. keys（）==> 取键
15. cars = {'bmw':88, 'benchi':83,'tesila':95}
16. kys = cars.keys()
17. print(kys)
18. print(type(kys))
19. print(list(kys))
20. print(list(kys)[1])
22. dict_keys(['bmw', 'benchi', 'tesila'])
23. <class 'dict_keys'>
24. ['bmw', 'benchi', 'tesila']
25. benchi
27. cars = {'bmw':88, 'benchi':83,'tesila':95}
28. vals = cars.values()
29. print(vals)
30. print(type(vals))
31. print(list(vals))
32. print(list(vals)[1])
34. dict_values([88, 83, 95])
35. <class 'dict_values'>
36. [88, 83, 95]
37. 83

复制代码

程序调用字典的三个方法后，都需要调用给他们转成列表，这样就可以吧这三个方法的返回值转成列表
1.3 pop()

用于获取指定的key对应的value值，并且删除这个键值对

1. cars = {'bmw':88, 'benchi':83,'tesila':95}
2. print(cars.pop('tesila'))
3. print(cars)
5. 95
6. {'bmw': 88, 'benchi': 83}

复制代码

1.4 setdefault()

能返回指定的key对应的value值，如果键值对不存在，就会先为这个键设置默认的值，再返回这个键对应的值

1. cars = {'bmw':88, 'benchi':83,'tesila':95}
2. print(cars.setdefault('baoshijie',92))#两个参数，第二个是设置默认值，如果不存在就会新增键值对
3. print(cars)
5. 92
6. {'bmw': 88, 'benchi': 83, 'tesila': 95, 'baoshijie': 92}

复制代码

2.1 字典

2.1.1公共功能

长度

1. info = {'age':12, 'shengming':True, 'name':'fe'}
2. data = len(info)
3. print(data)
5. 3

复制代码

索引（键）

1. info = {'age':12, 'shengming':True, 'name':'fe'}
2. print(info['name']) # fe  字典 通过键 查找值
3. print(info['age'])  #12
4. print(info['xxx'])  # 报错  如果键不存在会报错
6. fe
7. 12
8. 报错
10. value = info.get('xxx') # 使用get方法获取值如果不存在就打印None
11. print(value)
12. None

复制代码

for循环

1. info = {'age':12, 'shengming':True, 'name':'fe'}
2. #直接遍历这个字典，可以获取所有的键
3. for item in info:
4.     print(item)  #所有键
5.    
6. age
7. shengming
8. name
9. #使用keys方法
10. for item in info.keys():
11.     print(item)  # 所有键
12.    
13. #使用values方法
14. for item in info.values():
15.     print(item)  # 所有值
16.    
17. #使用items方法
18. for key,value in info.items():
19.     print(key,value)  #  获取所有的键值

复制代码

2.2 集合

元素都是唯一的，互不相同的

1. {name1, name2, .....name n}
2. 语法：
3. 集合名 = {数据1，数据2，数据3，。。。。数据n}#如果有重复的数据，是不会被添加到内存空间里面

复制代码

无法存储列表，字典，集合这些数据类型，否则会报错

1. #报错
2. print({{'a':1}})
3. print({[1,2,3]})
4. print({{1,2,3}})

复制代码

要注意的是：集合中的数据必须保证是唯一的，集合对于美中数据元素，只会保留一份，也就是去重

1. s = {1,2,1,(1,2,3),'c','c'}
2. print(s)
4. {1, 2, (1, 2, 3), 'c'}

复制代码

python中set是没有顺序的，每次输出时顺序都有可能不同

1. set1 = {1,2,3,4,5,5,1,2,3,4,5,6,7,9,1}
2. print(set1)
3. # print(set1[1])
4. print(type(set1))
6. {1, 2, 3, 4, 5, 6, 7, 9}
7. <class 'set'>

复制代码

注意 ：创建空集合的时候必须要使用set（）而不是{}，因为{}默认是空字典

1. li1 = [] # 空列表
2. tu1 = () # 空元组
3. str1 = '' # 空字符串
4. dict1 = {} # 空字典
5. set1 = set() #空集合

复制代码

1. # 去重并转为列表输出
2. li = [1,2,3,4,5,6,7,89,41,1,1,1]
3. # li1 = set(li)
4. # li2 = list(li1)
5. # print(li1)
6. # print(li2)
8. print(list(set(li)))
9. [1, 2, 3, 4, 5, 6, 7, 41, 89]

复制代码

2.2.1 集合的数学运算

运算符操作python运算符含义交集&取两集合公共的元素并集|取两集合全部的元素差集-取一个集合中另一集合没有的元素成员运算in 和 not in判断某个元素是否在或者不在集合中

1. 集合1 & 集合2——》判断交集
2. 集合2 | 集合1——》判断并集
3. 集合1 - 集合2——》判断差集
5. 交集：两个集合里面共同有的数据
6. 并集：两个集合里面的全部数据（不包括重复数据，集合本身也不能重复）
7. 差集：集合1 - 集合2  减去共有的，剩下的就是差集
10. set1 = {1,2,3}
11. set2 = {3,4,5}
12. print(set1 & set2)
13. print(set1 | set2)
14. print(set1 - set2)# 差集{1, 2} 取一个集合中另一个集合没有的元素，将set1中属于set2的元素删除
15. print(set2 - set1)# 4,5
16. print(3 in set2)
18. {3}
19. {1, 2, 3, 4, 5}
20. {1, 2}
21. {4, 5}
22. True

复制代码

集合的作用：

• 存储非重复数据
  
• 用于将序列类型去重，逻辑判断（交集，并集，差集）
  

2.2.2 增

add() 参数为要添加的对象，通过多次添加数据可以发现添加后的元素位置不确定

1. 语法： 集合名.add（元素）
2. s = {'Java'}
3. s.add('python')
4. print(s)
5. s.add('go')
6. print(s)
7. s.add('c')
8. print(s)
9. s.add('c++')
10. print(s)
12. {'Java', 'python'}
13. {'go', 'Java', 'python'}
14. {'go', 'Java', 'python', 'c'}
15. {'c', 'c++', 'go', 'python', 'Java'}

复制代码

update() 参数为序列类型，会将每一个元素迭代添加到序列中（随机添加）

1. s = {'fe'}
2. s.update('123')
3. print(s)
4. s.update([4,5,6])
5. print(s)
7. {'3', '2', 'fe', '1'}
8. {'2', 4, 5, 6, '3', '1', 'fe'}

复制代码

2.2.3 删

pop（）随机删除一个元素

1. 实际上在进行代码实验的时候并不是随机的
2. 仅仅是在集合元素是字符串类型时，并且在cmd运行的时候才会随机删除，pycharm中默认保持删除第一个元素
3. s = {'fe'}
4. s.update('123')
5. print(s)
6. s.update([4,5,6])
7. print(s)
8. s.pop()
9. print(s)
10. s.pop()
11. print(s)
13. {'2', '1', 'fe', '3'}
14. {'1', 4, 'fe', 5, 6, '2', '3'}
15. {4, 'fe', 5, 6, '2', '3'}
16. {'fe', 5, 6, '2', '3'}

复制代码

remove（参数）有参数，参数就是要删除的元素，如果元素不存在就报错

1. 集合名.remove（元素）
2. s = {'fe'}
3. s.update('123')
4. print(s)
5. s.update([4,5,6])
6. print(s)
7. s.remove('1')
8. print(s)
9. s.remove('2')
10. print(s)
11. s.remove('8')
12. print(s)
14. {'1', 'fe', '2', '3'}
15. {4, 5, 6, '3', '1', '2', 'fe'}
16. {4, 5, 6, '3', '2', 'fe'}
17. {4, 5, 6, '3', 'fe'}
18. 报错

复制代码

discard()跟remove相似，但是元素不存在也不会报错

1. s = {'fe'}
2. s.update('123')
3. print(s)
4. s.update([4,5,6])
5. print(s)
6. s.discard('aaa')
7. print(s)
9. {'3', '1', 'fe', '2'}
10. {4, 5, 6, '3', 'fe', '1', '2'}
11. {4, 5, 6, '3', 'fe', '1', '2'}

复制代码

clear() 清空集合中的元素

1. s = {'fe'}
2. s.update('123')
3. print(s)
4. s.update([4,5,6])
5. print(s)
6. s.clear()
7. print(s)
9. {'1', '3', '2', 'fe'}
10. {'2', 4, 5, 6, 'fe', '3', '1'}
11. set()

复制代码

del () 集合名（），删除集合

1. # 整个吧盒子（变量）删除了，所以会报错，先删除了盒子，再去打印这个s就会报错显示盒子s不存在
2. s = {'fe'}
3. s.update('123')
4. print(s)
5. s.update([4,5,6])
6. print(s)
7. del s
8. print(s)

复制代码

2.2.4 改

1. 由于set中的数据没有索引，也没有办法去定位一个元素，所以没办法直接修改
2. 先删除在添加
3. s = {'A', 'B', 'C', 'D'}
4. # 把A改为E
5. s.remove('A')
6. s.add('E')
7. print(s)
9. {'B', 'E', 'C', 'D'}

复制代码

2.2.5查

1. set是一个可迭代对象，可以通过for循环进行遍历查询
2. s = {'A', 'B', 'C', 'D'}
3. for i in s:
4.     print(i)
5.    
6. A
7. C
8. D
9. B

复制代码

1. 复习巩固 练习题
2. 在终端中获取颜色（RGBA），打印描述信息，否则提示颜色不存在
3.     "R" -->"红色"
4.     "G" -->"绿色"
5.     "B" -->"蓝色"
6.     "A" -->"透明度"

复制代码

1. # 1.将列表数据[1,2,3,2,1,4,4,4,2,5,6,7,7,9,8,10,10]去重
2. li1 = [1,2,3,2,1,4,4,4,2,5,6,7,7,9,8,10,10]
3. li2 = []
4. for i in li1:
5.     if i not in li2:
6.         li2.append(i)
7. print(li2)
8. #或者
9. print(list(set(li1)))
11. # 2.有字典 dic = {"k1": "v1", "k2": "v2", "k3": "v3"},实现以下功能:
12. # (1)、遍历字典 dic 中所有的key
13. dic = {"k1": "v1", "k2": "v2", "k3": "v3"}
14. for key in dic.keys():
15.     print(key)
16. # (2)、遍历字典 dic 中所有的value
17. for value in dic.values():
18.     print(value)
19. # (3)、循环遍历字典 dic 中所有的key和value
20. for key,value in dic.items():
21.     print(key,value)
22. # (4)、添加一个键值对"k4","v4",输出添加后的字典 dic
23. dic['k4'] = 'v4'
24. print(dic)
25. # (5)、删除字典 dic 中的键值对"k1","v1",并输出删除后的字典 dic
26. dic.pop('k1')
27. print(dic)
28. # (6)、获取字典dic中“k2”对应的值
29. print(dic.get('k2'))
31. students = [
32.     {'name': 'Java', 'age': 18, 'score': 98, 'tel': '18888888888', 'gender': 'female'},
33.     {'name': 'c', 'age': 20, 'score': 95, 'tel': '18888888889', 'gender': 'unkown'},
34.     {'name': 'python', 'age': 18, 'score': 88, 'tel': '18888888810', 'gender': 'male'},
35.     {'name': 'c++', 'age': 16, 'score': 58, 'tel': '18888888811', 'gender': 'unkown'},
36.     {'name': 'php', 'age': 19, 'score': 78, 'tel': '18888888812', 'gender': 'male'},
37.     {'name': 'go', 'age': 17, 'score': 92, 'tel': '18888888813', 'gender': 'male'},
38. ]
39. # （1）统计及格学生的个数
40. count = 0 #初始化一个值
41. for d in students:
42.     if d['score'] >= 60:
43.         count += 1
44. print(count)
46. # （2）打印不及格学生的名字和对应的成绩
47. for d in students:  #d是字典
48.     if d['score'] < 60:
49.         print(d['name'],d['score'])
50. # （3）删除性别不明的所有的学生
51. for d in students:
52.     if d['gender'] == 'unkown':
53.         #pop根据下标  remove根据值删除  clear 清空  del 列表名[下标]
54.         students.remove(d)  # 删除性别不明
55. print(students)

复制代码

复习巩固答案

1. 1.编写一个程序，检查任意一个年份是否是闰年
2. - 如果一个年份可以被4整除不能被100整除，或者可以被400整除，这个年份就是闰年
3. year = int(input('请输入一个年份：'))
4. if year % 4 == 0 and year % 100 != 0 or year %400 == 0:  # ！= 不相等
5.     print(year,'是闰年')
6. else:
7.     print(year,'是平年')
9. 2.从键盘输入小明的期末成绩：
10.         当成绩为100时，'奖励一辆BMW'
11.     当成绩为(80-99)时，'奖励一台iphone'
12.     当成绩为(60-79)时，'奖励一本参考书'
13.     其他时，奖励棍子一根
15. 3.计算1+2+3+...+100（使用while循环）
17. num = 1
18. sum = 0  # 初始化一个累计的变量
19. while num < 101:
20.     sum += num
21.     num += 1  # num1 =num + 1
22. print('num=',sum)
24. 4.打印99乘法表：
25. 1*1=1
26. 1*2=2        2*2=4
27. 1*3=3        2*3=6        3*3=9
28. 1*4=4        2*4=8        3*4=12        4*4=16
29. 1*5=5        2*5=10        3*5=15        4*5=20        5*5=25
30. 1*6=6        2*6=12        3*6=18        4*6=24        5*6=30        6*6=36
31. 1*7=7        2*7=14        3*7=21        4*7=28        5*7=35        6*7=42        7*7=49
32. 1*8=8        2*8=16        3*8=24        4*8=32        5*8=40        6*8=48        7*8=56        8*8=64
33. 1*9=9        2*9=18        3*9=27        4*9=36        5*9=45        6*9=54        7*9=63        8*9=72        9*9=81
35. for i in range(1,10):
36.     for j in range(1,i+1):
37.         print(i,'*',j,'=',i*j,end='\t')
38.     print()

复制代码

五 数据类型进阶（下）

python的数据类型可以分为三类：数值类型，序列类型，散列类型
数值类型：int , float , bool
2.1 序列类型

1. 元素1  元素2   元素3  元素4 元素。。。。 元素n
2. 0      1      2       3    4         n-1
3. -n
5. # 元素下面的是索引取值

复制代码

1. s = 'CSDN博客论坛'
2. print(s[0],'=',s[-8])
3. print(s[-1],'=',s[7])
5. C = C
6. 坛 = 坛

复制代码

2.2 字符串  str

字符串是一个有序的字符集和，用于存贮和表示基本的文本信息
2.2.1 常用方法

操作数据最本质的行为是什么？== 》增删改查

1. 字符串.方法名

复制代码

2.2.1.1 find

find的作用：范围性查找子串，返回索引值，没有则返回-1
语法：

1. str.find(str，beg=0,end=len(string))

复制代码

• str==> 指定检索的字符串
  
• beg==》开始的索引，默认值为0
  
• end==》结束的索引，默认为字符串的长度
  

find常用于检测字符串中是否包含子字符串str

1. s = 'hello world'
2. print(s.find('o'))  #o 的索引值就是4
3. print(s.find('hello')) # 找到hello则返回首个字符的索引
4. print(s.find('worldd')) # 找不到返回-1
6. s = ('python,helloworld,java,php')
7. print(s.find('h'))  # 返回的是首个h的下标
8. print(s.find('h',4))  # 从下标为4的地方开始找
9. print(s.rfind('h'))  # 从后往前找

复制代码

2.2.1.2 index（）

检测字符串中是否包含子字符串str，如果指定beg和end范围，则检查是否包含在指定范围内，和find差不多，只不过如果子str不在str中会报错

1. s = ('python,helloworld,java,php')
2. print(s.index('world'))  # 12 索引值
3. print(s.index('worldd'))  # 报错

复制代码

2.2.1.3 count（）

返回找到的子串个数

1. s = ('python,helloworld,java,php')
2. print(s.count('h'))  # 3 h的个数

复制代码

2.2.1.4 strip（）

去除字符串两边的空格，换行符，制表符，得到的是一个新的字符串

1. code = input('请输入4位的验证码：')
2. data = code.strip()
3. if data == 'ABCD':
4.     print('验证码正确')
5. else:
6.     print('验证码错误')

复制代码

2.2.1.5 startswith(), endswith()

• 判断字符串是否已xx开头，得到一个布尔值
  

1. dizhi = input('请输入住址：')
2. if dizhi.startswith('北京市'):
3.     print('北京人口')
4. else:
5.     print('非北京人口')

复制代码

• 判断字符串是否已xx结尾，得到一个布尔值
  

1. dizhi = input('请输入住址：')
2. if dizhi.endswith('村'):
3.     print('农业户口')
4. else:
5.     print('非农业户口')

复制代码

1. s = '北京市朝阳区'
2. print(s.startswith('北京市'))

复制代码

2.2.1.6 isdigit（）

• 判断字符串是否是数字组成，返回的结果是布尔值
  

1. v1 = input('请输入第一个值：')
2. v2 = input('请输入第二个值：')
3. if v1.isdigit() and v2.isdigit():
4.     data = int(v1)+int(v2)
5.     print(data)
6. else:
7.     print('请输入正确的数字')

复制代码

2.2.1.7lower（） 和 upper（）

字符串变大写/小写，得到一个新的字符串
lower（）==》转小写
upper（）==》转大写

1. s = 'C'
2. print(s)
3. s1 = s.lower()
4. print(s1)
5. s2 = s1.upper()
6. print(s2)
8. C
9. c
10. C

复制代码

2.2.1.8 split（）

切分字符串，将字符串类型转成列表，默认以空格切分，也可以指定字符切分

1. s = 'my name is zuoshou'
2. print(s.split())
3. s1 = 'python,helloworld,java,php'
4. print(s1.split(','))
6. ['my', 'name', 'is', 'zuoshou']
7. ['python', 'helloworld', 'java', 'php']

复制代码

2.2.1.9 replace（）

字符串内容的替换，得到一个新的字符串

1. s = input('请输入评论信息：')
2. s1 = s.replace('草','*')
3. print(s1)

复制代码

2.2.1.10 join()

用于将序列中的元素以指定的字符串连接生成一个新的字符串
常用于将列表转为字符串

1. a = ['Java', '和', 'python', '是', '好朋友']
2. print(''.join(a))  # 常用于转化列表为字符串时使用
3. print('-'.join(a))
5. Java和python是好朋友
6. Java-和-python-是-好朋友

复制代码

2.2.2 字符串的公共功能

2.2.2.1正向取（从左往右），反向取（从右往左，负号）

1. s = 'hello python'
2. # 正向取值
3. print(s[0])  #  取值为 h
4. print(s[5])  #  空格，空格也算是字符串里的一个字符
5. # 反向取值
6. print(s[-4]) # 取值为 t
8. len的用法
9. len 是从1开始数  计量字符串长度
10. print(s[len(s)-1])  # 最后一个值
11. print(len(s))   # len  计算字符串的长度
12. print(s[-len(s)])  # len 前面加负号 是从右到左取值

复制代码

2.2.2.2 切片（顾头不顾尾，步长）

1. s = 'hello python'
2. print(s[::2])
4. hlopto
6. 步长：0:9:2 第三个参数2代表步长，会从下标0开始，每次累加一个2就可以
7. print(s[0:9:2])
9. hlopt
11. print(s[::-1]) # 从右到左依次取值 反向取值 步长为负数就是从右到左 首尾不给值就是取所有
12. nohtyp olleh

复制代码

2.3 列表 list

可以存放多个不同类型的元素，记录多个同种属性的值
列表：存贮同一个类别的数据，方便操作

1. 字符串，不可变类型：创建好之后内部无法修改[内置功能都是新创建一份数据]
2. name = 'java'
3. data = name.upper()
4. print(name)
5. print(data)
7. java
8. JAVA  

复制代码

1. 列表，可变类型：创建好之后内部元素可以修改[独有功能基本上都是直接操作列表内部的，不会创建一份新的数据]
3. list1 = ['车子', '房子']
4. list1.append('妹子')  # append  ’添加‘的方法
5. print(list1)
7. ['车子', '房子', '妹子']

复制代码

列表的创建

1. 列表名 = []

复制代码

2.3.1 增

1. 1.append:添加一个数据，添加到列表的最后一位
2.    语法： 列表名.append('python')
3. li..append('python')
4. print(li)
5. [2, 3, 4, 5, 6, 7, 8, 9, 10, 'python']
7. 2.insert: 添加一个数据到指定位置
8.     语法：列表名.insert(下标位置，内容)
9.    li.insert(0,'look')
10. print(li)
11. ['look', 2, 3, 4, 5, 6, 7, 8, 9, 10, 'python']
13. 3.extend:添加一个序列类型到最后一位,并且吧序列类型拆分
14.     语法:列表名.extend（序列类型）
15.   li.extend('吸血鬼')
16. print(li)
17. li.extend(['吸血鬼'])
18. print(li)
19. ['look', 2, 3, 4, 5, 6, 7, 8, 9, 10, '左手', '吸', '血', '鬼']
20. ['look', 2, 3, 4, 5, 6, 7, 8, 9, 10, '左手', '吸', '血', '鬼', '吸血鬼']

复制代码

2.3.2 删

1. pop:删除一个值，默认从最后一个开始删，也可以指定位置
2.     语法：列表名.pop()
3.     列表名.pop(下标)
4.     li.pop(-1)
5. print(li)
6. ['look', 2, 3, 4, 5, 6, 7, 8, 9, 10, 'python', '吸', '血', '鬼']
8. remove:删除一个指定的值，如果有多个，从第一个开始删
9.     语法：列表名.remove(删除对象)
10.     li.remove(3) # 删除对象
11. print(li)
13. ['look', 2, 4, 5, 6, 7, 8, 9, 10, 'python', '吸', '血', '鬼']
15. clear :清空列表里面的所有数据
16.     语法：列表名.clear()
17.     li.clear()
18. print(li)
20. []
21. del : 全局删除，可以删除一个变量
22.     语法：del 列表名[下标]
23. del li[3]  # 下标
24. print(li)
26. ['look', 2, 4, 6, 7, 8, 9, 10, 'python', '吸', '血', '鬼']

复制代码

2.3.3 改

1. 单个修改：直接通过下标进行修改
2. 语法：列表名[下标] = 内容
3. li[1] = '阿尔法'
4. print(li)
5. ['look', '阿尔法', 4, 6, 7, 8, 9, 10, 'python', '吸', '血', '鬼']
7. 多个修改：通过切片的方式进行修改
8. 语法： 列表名[起点:终点] = 数值1, 数值2
9. li[1:3] = 70,20
10. print(li)
11. ['look', 70, 20, 6, 7, 8, 9, 10, '左手', '吸', '血', '鬼']

复制代码

2.3.4查

1. index:根据内容获取指定数据的下标
2.     语法：列表名。index(要找的内容)
3.     print(li)
4. print(li.index(8))
5. 5
6. 列表名。index(要找的内容，起点值)
7. print(li.index(20,5)) #报错，显示20不在列表中
9. count:统计数据出现的次数
10.     语法：列表名.count（要找的内容）
11.     print(li.count(10))
12.           1

复制代码

2.3.5 其他

1. 排序(全int的列表才可以排序)
2. sort:让列表的内容按照降序/升序的方式来排序
3.     列表名.sort()——》升序
4. li1 = [1,85,6,8,61,3,45321,1965]
5. li1.sort()
6. print(li1)
8. [1, 3, 6, 8, 61, 85, 1965, 45321]
10.     列表名.sort(reverse=True)——》降序
11. li1 = [1,85,6,8,61,3,45321,1965]
12. li1.sort(reverse=True)
13. print(li1)
15. [45321, 1965, 85, 61, 8, 6, 3, 1]

复制代码

来源:https://www.cnblogs.com/xw-01/p/17555170.html
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！