1. 数字类型
1 # 1.整型
2 num = -1000000000000000000000000000000000000000000000000
3 print(num, type(num))
4
5 # 2.小数
6 num = 3.14
7 print(num, type(num))
8
9 # 3.布尔
10 res = True
11 print(res, type(res), isinstance(res, int))
12 print(3.14 + True)
13
14 # 4.复数
15 num = complex(5, 4) # 5 + 4j
16 print(num + (4 + 5j))
17
18 # 数字类型直接的相互转化 *****
19 a = 10
20 b = 3.74
21 c = True
22 print(int(a), int(b), int(c))
23 print(float(a), float(b), float(c))
24 print(bool(a), bool(b), bool(c))
2. 字符串类型
1 # 1.定义: 可以有多种引号嵌套
2
3 # 需求：你是"好学生"
4 s1 = "你是\"好学生\""
5 print(s1)
6 # 可以通过引号的嵌套，使内部不同的引号在不转义的情况下直接输出
7 s2 = '你是"好学生"'
8 print(s2)
9
10 # 需求：你是"好学生"，是'我的'
11 s3 = """你是"好学生"，是'我的'"""
12 print(s3)
2.1 字符串的常规操作
1 # 1.字符串的索引取值: 字符串[index]
2 # 正向取值从0编号，反向取值从-1编号
3 s1 = '123abc呵呵'
4 print(id(s1)) # 2217572683576
5 print(s1[0], id(s1[0])) # 2217543167200
6 t_s = '1'
7 print(id(t_s)) # 2217543167200
8 # 取出c
9 print(s1[5], s1[-3])
10
11 # 2.字符串拼接
12 s2 = '你好'
13 s22 = '帅'
14 ss2 = s2 + s22
15 print(ss2, id(s2), id(s22), id(ss2))
16 # 如果要拼接其他类型
17 a = 10
18 b = "20"
19 c = True
20 # res = "1020True"
21 res = "%s%s%s" % (a, b, c) # 方法1
22 print(res)
23 res = str(a) + b + str(c) # 方法2
24 print(res)
25
26 # 3.字符串长度
27 s3 = '12345'
28 ln1 = s3.__len__()
29 print(ln1)
30 ln2 = len(s3)
31 print(ln2)
32
33
34 # 4.字符串切片: 取子字符串 - [::] - [start_index:end_index:step]
35 s4 = '123abc呵呵'
36 sub_s = s4[0:6:]
37 print(sub_s) # 123abc
38 sub_s = s4[0:6:2]
39 print(sub_s) # 13b
40 sub_s = s4[::-1]
41 print(sub_s) # 呵呵cba321
42 sub_s = s4[-1:-6:-1]
43 print(sub_s) # 呵呵cba
44
45 # 5.成员运算：判断某字符串是否在该字符串中
46 s5 = '123abc呵呵'
47 ss5 = '12a'
48 print(ss5 in s5) # False
49 print(ss5 not in s5) # True
50
51
52 # 6.字符串循环(遍历)
53 s6 = '123abc呵呵'
54 for v in s5:
55 print(v)
2.2 字符串中的重要方法
1 # 1.索引(目标字符串的索引位置)
2 s1 = '123abc呵呵'
3 print(s1.index('b'))
4
5 # 2.去留白(默认去两端留白，也可以去指定字符)
6 s2 = '***好 * 的 ***'
7 print(s2.strip('*'))
8
9 # 3.计算子字符串个数
10 s3 = '12312312'
11 print(s3.count('123'))
12
13 # 4.判断字符串是否是数字:只能判断正整数
14 s4 = '123'
15 print(s4.isdigit())
16
17 # 5.大小写转换
18 s5 = "AbC def"
19 print(s5.upper()) # 全大写
20 print(s5.lower()) # 全小写
21 # 了了解
22 print(s5.capitalize()) # 首字母大写
23 print(s5.title()) # 每个单词首字母大写
24
25 # 6.以某某开头或结尾
26 s6 = 'https://www.baidu.com'
27 r1 = s6.startswith('https:')
28 r2 = s6.startswith('http:')
29 r3 = s6.endswith('com')
30 r4 = s6.endswith('cn')
31 if (r1 or r2) and (r3 or r4):
32 print('合法的链接')
33 else:
34 print('非合法的链接')
35
36 # 7.替换
37 s7 = 'egon say: he is da shuai b，egon！egon！egon！'
38 new_s7 = s7.replace('egon', 'Liu某') # 默认替换所有
39 print(new_s7)
40 new_s7 = s7.replace('egon', 'Liu某', 1) # 替换一次
41 print(new_s7)
42
43 # 8.格式化
44 s8 = 'name：{}，age：{}'
45 print(s8.format('Owen', 18)) # 默认按位置
46 print('name：{1}，age：{1}, height：{1}'.format('Owen', 18)) # 标注位置，一个值可以多次利用
47 print('name：{n}，age：{a}, height：{a}'.format(a=18, n="Zero")) # 指名道姓
2.3 字符串了解方法
1 '''
2 1. find | rfind：查找子字符串索引，无结果返回-1
3 2. lstrip：去左留白
4 3. rstrip：去右留白
5 4. center | ljust | rjust | zfill：按位填充
6 语法：center(所占位数, '填充符号')
7 5. expandtabs：规定\t所占空格数
8 6. captialize | title | swapcase：首字母大写 | 单词首字母大写 | 大小写反转
9 7. isdigit | isdecimal | isnumeric：数字判断
10 8. isalnum | isalpha：是否由字母数字组成 | 由字母组成
11 9. isidentifier：是否是合法标识符
12 10. islower | isupper：是否全小 | 大写
13 11. isspace：是否是空白字符
14 12. istitle：是否为单词首字母大写格式
15 '''
3 列表类型
# 定义：
# 1.list中可以存放多个值，可以存放所有类型的数据
# 2.list中有序的，可以通过索引取值
3.1 常规操作
1 # 1.索引取值: 列表名[index]
2 s1 = [1, 3, 2]
3 print(s1[0])
4 print(s1[-1])
5
6 # 2.列表运算: 得到的是新list
7 s2 = [1, 2, 3]
8 print(s2 + s2)
9 print(s2 * 2)
10 print(s2)
11
12 # 3.list的长度
13 s3 = [3, 4, 1, 2, 5]
14 print(len(s3))
15
16 # 4.切片：[start_index:end_index:step]
17 s4 = [3, 4, 1, 2, 5]
18 new_s4 = s4[::-1]
19 print(new_s4)
20 new_s4 = s4[1:4:]
21 print(new_s4)
22 new_s4 = s4[-2:-5:-1]
23 print(new_s4)
24
25 # 5.成员运算：in
26 s5 = [3, 4, '1', 2, 5]
27 print('1' in s5)
28 print(1 in s5)
29 print(5 not in s5)
30
31 # 6.循环
32 for v in s5:
33 print(v, type(v))
34
35 # 只打印数字类型的数据
36 for v in s5:
37 if isinstance(v, int):
38 print(v, end=' ')
3.2 列表的增删改查
1 # 1.列表的增删改查
2 ls = [1, 2, 3]
3
4 # 查
5 print(ls)
6 print(ls[1])
7
8 # 增
9 ls.append(0) # 末尾增
10 print(ls)
11 ls.insert(1, 666) # 任意index前增
12 print(ls)
13 ls.insert(len(ls), 888) # insert实行末尾增
14 print(ls)
15
16 # 改
17 ls[1] = 66666
18 print(ls)
19
20 # 删
21 ls.remove(888)
22 print(ls)
23 res = ls.pop() # 默认从末尾删，并返还删除的值
24 print(res)
25 res = ls.pop(1) # 从指定索引删除，并返还删除的值
26 print(res, ls)
27 # 了了解
28 del ls[2]
29 print(res, ls)
30 # 清空
31 ls.clear()
32 print(ls)
33
34
35 # 2.其他方法
36 # 1）排序: 针对于同类型
37 ls = ['3', '1', '2']
38 ls.sort() # 默认正向排序
39 print(ls)
40 ls.sort(reverse=True) # 正向排序结果上翻转，形成倒序
41 print(ls)
42
43 # 2）翻转
44 ls = ['3', '1', '2']
45 ls.reverse() # 按存储的顺序进行翻转
46 print(ls)
47
48 # 3）计算值的个数 => 列表中可以存放重复数据
49 ls = [1, 2, 1, 2, 3, 1]
50 print(ls.count(1)) # 对象1存在的次数
51
52 # 4）整体增加，添加到末尾
53 ls = [1, 2, 3]
54 ls.extend('123')
55 print(ls)
56 ls.extend([0, 1, 2])
57 print(ls)
58
59 # 目标的索引位置，可以规定查找区间
60 ls = [1, 2, 1, 2, 3, 1]
61 # 找对象1，在索引3开始往后找到索引6之前
62 ind = ls.index(1, 3, 6)
63 print(ind)
3.3 列表了解方法
1 # 1）排序: 针对于同类型
2 ls = ['3', '1', '2']
3 ls.sort() # 默认正向排序
4 print(ls)
5 ls.sort(reverse=True) # 正向排序结果上翻转，形成倒序
6 print(ls)
7
8 # 2）翻转
9 ls = ['3', '1', '2']
10 ls.reverse() # 按存储的顺序进行翻转
11 print(ls)
12
13 # 3）计算值的个数 => 列表中可以存放重复数据
14 ls = [1, 2, 1, 2, 3, 1]
15 print(ls.count(1)) # 对象1存在的次数
16
17 # 1）整体增加，添加到末尾
18 ls = [1, 2, 3]
19 ls.extend('123')
20 print(ls)
21 ls.extend([0, 1, 2])
22 print(ls)
23
24 # 2) 目标的索引位置，可以规定查找区间
25 ls = [1, 2, 1, 2, 3, 1]
26 # 找对象1，在索引3开始往后找到索引6之前
27 ind = ls.index(1, 3, 6)
28 print(ind)
4 元组
1 '''
2 元组：可以理解为不可变的列表
3 # 1.值可以为任意类型
4 # 2.可以存放多个值 - 可以进行成员运算
5 # 3.可以存放重复的值 - 可以计算成员出现的次数
6 # 4.有序存储 - 可以通过索引取值，可以切片
7 '''
8 # 常用操作
9 # 1.索引取值
10 print(t1[1], type(t1[1]))
11 print(t1[-3])
12
13 # 2.运算(拼接)
14 print((1, 2) + (2, 3))
15
16 # 3.长度
17 print(len(t1))
18
19 # 4.切片
20 print((2, 1, 3)[::-1])
21
22 # 5.成员运算
23 print(True in t1)
24 print(False in t1) # False == 0， t1中如果有0或False，该结果都是True
25
26 # 6.for循环
27 for obj in t1:
28 print(obj, end=" ")
29 print()
30
31
32 # 方法
33 print(t1.count(0)) # 对象0在元组中出现的次数
34
35 print(t1.index(123, 4, len(t1))) # 对象0在区间4~末尾第一次出现的索引
5 字典类型
5.1 字典相关概念
1 # 容器(集合)：存放多个值的变量
2 # 单列容器(系统中的单列容器很多)：list | tuple
3 # 双列容器(map)：只有dict，存放数据 成对出现，dict存放数据采用 key-value键值对方式
4
5
6 # 字典中的key可以为什么类型：key必须为不可变类型
7 # -- key是取value的唯一依据，key一旦被确定，就需要唯一确定(不能被改变)
8 # 字典中的value可以为什么类型：value可以为任意类型
9 # -- value是用来存放世间所有存在的数据
10
11 # key要确保唯一性，不能重复，值可以重复，并且可以被改变 => 字典为可变类型
12
13 dic = {'a': 10, 1: 20, True: 30, (): 40} # 1和True都是1，key具有唯一性，所以只保留最后一次值
14 print(dic) # {'a': 10, 1: 30, (): 40}
5.2 字典的定义
1 # 空字典
2 d1 = {}
3 d2 = dict()
4 # 用map映射创建字典
5 d3 = dict({'a': 1, 'b': 1})
6 print(d3)
7 # 用关键字赋值方式
8 d4 = dict(name='Bob', age=18) # 参数=左侧的名字就是合法的变量名，都会被转化为字符串形式的key
9 print(d4)
10 # 创建有多个key值采用默认值的方式: 默认值不写默认None，也可以自定义
11 d5 = {}.fromkeys('abc', 0)
12 print(d5)
5.3 字典的操作
1 dic = {'a': 1, 'b': 2}
2 print(dic)
3
4 # 增: 字典名[key] = 值 => key已存在就是修改值，不存在就是新增值
5 dic['c'] = 3
6 print(dic)
7 # 改
8 dic['c'] = 30
9 print(dic)
10 # 查:字典名[key]
11 print(dic['c']) # 只能查找已有的key，没有崩溃
12 # 有默认值的查询：有key取出对应value，没有返还默认值，默认值可以自定义
13 print(dic.get('d', 'http://www.baidu.com'))
14 # 删
15 print(dic)
16 # 清空
17 # dic.clear()
18 # pop(k)删除指定key的value并返还删除的value
19 # res = dic.pop('a')
20 # 从dic末尾删除，返还(key, value)形成的元组
21 res = dic.popitem()
22 print(dic, res)
23
24
25 # 其他方法
26 # 更新: a有值覆盖，c没被新操作，带下来，b为新增，增加并赋值
27 dic = {'a': 1, 'c': 2}
28 d = {'a': 10, 'b': 20}
29 dic.update(d)
30 print(dic) # {'a': 10, 'c': 2, 'b': 20}
31
32 # 带默认值的新增: 新增key，key已有，啥事不干，没有添加key，值就是第二个参数
33 dic.setdefault('z', 100)
34 print(dic)
35
36
37 # 字典的循环
38 # 1.直接循环，就是循环得到key
39 # for k in dic:
40 # print(k)
41
42 # 2.循环keys
43 # print(dic.keys())
44 # for k in dic.keys():
45 # print(k)
46
47 # 3.循环values
48 # print(dic.values())
49 # for v in dic.values():
50 # print(v)
51
52 # 同时循环key和value (key, value)
53 print(dic.items())
54 # a, b = (1, 2)
55 # print(a, b)
56 # for res in dic.items():
57 # print(res)
58 # 重点
59 for k, v in dic.items():
60 print(k, v)
61
62 # 解压赋值
63 # a, _, _, b = (1, 2, 3, 4)
6 集合类型
1 # 空集合：不能用{},因为用来标示空字典
2 s = set()
3 print(s, type(s))
4
5 # 概念：
6 # 1.set为可变类型 - 可增可删
7 # 2.set为去重存储 - set中不能存放重复数据
8 # 3.set为无序存储 - 不能索引取值
9 # 4.set为单列容器 - 没有取值的key
10 # 总结：set不能取值
11
12 # 增
13 s.add('1')
14 s.add('2')
15 s.add('1')
16 print(s)
17 s.update({'2', '3'})
18 print(s)
19
20 # 删
21 # res = s.pop()
22 # print(res)
23 # s.remove('1')
24 # print(s)
25 s.clear()
26 print(s)
27
28
29 # set运算
30 # 交集：两个都有 &
31 py = {'a', 'b', 'c', 'egon'}
32 lx = {'x', 'y', 'z', 'egon'}
33 print(py & lx)
34 print(py.intersection(lx))
35
36 # 合集：两个的合体 |
37 print(py | lx)
38 print(py.union(lx))
39
40 # 对称交集：抛出共有的办法的合体 ^
41 print(py ^ lx)
42 print(py.symmetric_difference(lx))
43
44 # 差集：独有的
45 print(py - lx)
46 print(py.difference(lx))
47
48 # 比较：前提一定是包含关系
49 s1 = {'1', '2'}
50 s2 = {'2'}
51 print(s1 < s2)
