一.程序交互
name = input(“你的名字是：”) #用户输入，输入的任何东西都存储成str（字符串类型）的形式
二.注释的重要性
以后动辄几千行代码的时候，回过头再去看的时候，发现自己都看不懂了，在工作中还会大家一起合作完成代码，不写注释的话，更难以交流了。
单行注释直接在句首写上#就好了
多行注释可用快捷键ctrl+/，或者用三个引号括起来''' 99999999
12345789
'''
#1. 不用全部加注释，只需要在自己觉得重要或不好理解的部分加注释即可
#2. 注释可以用中文或英文，但不要用拼音
三.基本数据类型（查看数据类型的方法type（））
1.数字类型
int（整型）
在32位机器上，整数的位数为32位，取值范围为-2**31～2**31-1，即-2147483648～2147483647
在64位系统上，整数的位数为64位，取值范围为-2**63～2**63-1，即-9223372036854775808～9223372036854775807
long（长整型）
跟C语言不同，python的长整数没有指定位宽，即：Python没有限制长整数数值的大小，但实际上由于机器内存有限，我们使用的长整数数值不可能无限大。
注意，自从Python2.2起，如果整数发生溢出，Python会自动将整数数据转换为长整数，所以如今在长整数数据后面不加字母L也不会导致严重后果了。
注意：在python3里不再有long类型了，全都是intfloat（浮点型）（精度限制17位，小数点后16位）
定义：salary=3.1 #salary=float(3.1)
用于标识：工资，身高，体重，
############ if a.isdigit(): # 判断是不是a数字2.字符串类型
python中，加了引号（单引号可以，双引号也可以，三个单引号也可以）的字符都叫字符串你需要考虑单双的配合（特殊情况，其他情况下随意）
msg = "My name is Alex , I'm 22 years old!"
多引号什么作用呢？作用就是多行字符串必须用多引号
字符串拼接：
字符串可以进行相加和相乘的操作
>>> a='hello'
>>> b=' world'
>>>
>>> a + b
'hello world'
>>> res=a + b
>>> print(res)
hello world
>>> a*3
'hellohellohello'
a.isdigit() # 判断一字符串是否只包括数字
a.replace('old','new',max) # old被替换的字符，new换成的字符，max最大替换次数
a.find() # 查找是否含有字符串，是返回索引值，否者返回-1
a.count() # 统计字符出现次数
a.strip() # 删除一个字符串
a.center(10,'-') # 左右填充10位的-
a.split('a',2) # 在a出现是地方进行切片(a也没有了)，切片2次
a.fORMat() 通过关键字
1 print('{名字}今天{动作}'.format(名字='陈某某',动作='拍视频'))#通过关键字
2 grade = {'name' : '陈某某', 'fenshu': '59'}通过位置
1 print('{1}今天{0}'.format('拍视频','陈某某'))#通过位置
2 print('{0}今天{1}'.format('陈某某','拍视频'))
a.join
>>> A = 'hello,world'
>>> ' '.join(A)
'h e l l o , w o r l d'
>>> '>'.join(A)
'h>e>l>l>o>,>w>o>r>l>d'3.布尔类型（bool）
布尔类型很简单，就只有两个值，一个真（true），一个假（false），主要用于逻辑运算
4.列表类型（list）
创建 name = ['张三'，‘王五’，‘李四’，1，2，5，4，5，4，‘李四’]
list('abc') # 结果为['a', 'b', 'c']
查询，取出 name[0] # 结果为'张三' name[-1] # 结果为'李四'
查询索引值 name.index('李四') # 结果为2，有重复的时候，只能找到第一个
查询重复出现的个数 name.count('李四') # 结果为2（个）
切片（顾头不顾尾） name[0:2] #结果为['张三','王五']
值得注意的是 name[-5:-1] # 结果为[5,4,5,4] name[-5:] # 结果才是[5,4,5,4,'李四']
中间隔一个取一个 name[7:2] # 结果为['张三','李四',2,4]
增加和修改 name.appeend('Xander') # 加到了最后面
name.insert(0,'lexi') # 插入到指定位置
修改（直接赋值就好了） name[1:3] = ‘abc’ # 批量修改‘王五’,‘李四’被修改成了'a','b','c'(中间还增加了一个)
删除 name.pop() # 删掉最后一个
name.remove('张三') # 删除索引到的第一个'张三'
del name[1] # 删掉了name[1],删除全局，可以删除任何东西
del name[1:5] # 批量删除
排序 n = ['a','c','b','f','e',1,3]
n1 = ['a','c','b','f','e']
n2 = [1,2]
n.sort() # 会报错int和str不能一起排序
n1.sort() # 会按照ASCII码表排序
反转 n.reverse()
拼接列表 n1 + n2 # 或者n1.extend(n2)
清空列表 n.clear()
copy n1 = n2 # 如果修改了n2列表中的值，n1也会一起被修改，这里和变量里面是不一样的
n1 = n2.copy() # 这个时候修改n2不会一起修改n1的值
5.元组（tuple） 1 """
2 元组【有序不可变】
3 作用：存多个值，对比列表来说，元组不可变（是可以当做字典的key的），主要是用来读
4 定义：
5 与列表类型比，只不过[]换成()
6 """
7
8 t = ('a',) # 元祖只有一个元素时，需要加逗号, 和字符串区分开
9 t = ('a', 'b', 'b', 'c') # 定义一个元组
10 t = tuple(('a', 'b', 'b', 'c'))
11
12 print(t.index('b')) # 索引出元素第一次出现的位置，还可以指定在某一范围里查找，这里默认在整个元组里查找输出1
13 print(t.count('b')) # 计算元素出现的次数，这里输出2
14 print(len(t)) # 输出远组的长度，这里输出4
15 print(t[1:3]) # 切片 输出('b','b')
16 for i in t:
17 print(i) # 循环打印出元组数据6.字典（dict）
1 """
2 字典【无序可变】
3 作用：存多个值,key-value存取，取值速度快
4 定义：
5 key必须唯一，必须是不可变类型，value可以是任意类型
6 """
7
8 # 创建：
9 info = {"name": "tom", "age": 18, "gender": "male"} # 本质info=dict({"name":"tom","age":18})
10 # info=dict(name='tom',age=18,gender='male')
11 # info=dict([['name','tom'],('age',18)])
12 # info={}.fromkeys(('name','age','gender'),None) #{'name': None, 'gender': None, 'age': None}
13
14 # 增加
15 info['salary'] = 50000 # {'name': 'tom', 'age': 18, 'salary': 50000, 'gender': 'male'}
16
17 # 删除
18 info.pop('age') # 根据键删除某一元素 d={'Michael': 95, 'Tracy': 85}
19 info.popitem() # 随机删除
20 info.clear() # {}
21
22 # 修改
23 info['age'] = '25' # 如果没有该key，则在字典创建新的的的key-value
24
25 # 查询
26 info.get('age') # 根据key获取values，如果不存在返回None，这里输出75
27 '''
28 setdefault的功能
29 1：key存在，则不赋值，key不存在则设置默认值
30 2：key存在，返回的是key对应的已有的值，key不存在，返回的则是要设置的默认值
31 '''
32 print(info.setdefault('age', 50000)) # 18
33 print(info.setdefault('salary', 50000)) # 50000
34 print(info) # {'age': 18, 'name': 'tom', 'salary': 50000, 'gender': 'male'}
35
36 # 其他
37 print(len(info)) # 输出字典长度
38 print('age' in info) # python3 中移除了 has_key,要判断键是否存在用in
39
40 for i in info:
41 print(i) # 循环默认按键输出
42
43 for i in info.values(): # 循环按值输出
44 print(i)
45
46 for k, v in info.items(): # 循环按键值输出
47 print(k, v)字典相关题目及答案
1 #创建一个字典
2
3 dic = {'k1':'v1','k2':'v2','k3':'v3'}
4
5 #1.请循环遍历出所有的KEY
6
7 for k in dic:
8
9 print(k)
10
11 #2请循环遍历出所有的value
12
13 for k in dic:
14
15 print(dic[k])
16
17 #3请循环遍历初所有的KEY和VALUE
18
19 for k in dic:
20
21 print(k,dic[k])
22
23 #4请在字典中添加一个键值对，'k4':'v4',输出添加后的字典
24
25 dic['k4'] = 'v4'
26
27 print(dic)
28
29 #5请删除字典中键值对'k1','v1',并输出删除后的字典
30
31 dic.pop('k1')
32
33 print(dic)
34
35 #6请删除字典中键'k5'对应的键值对，如果字典中不存在键'k5'，则不报错，并且让其返回none
36
37 if 'k5' in dic:
38
39 dic.pop('k5')
40
41 else:
42
43 print(dic.get('k5'))
44
45 #7请获取字典中'k2'对应的值
46
47 print(dic.get('k2'))
48
49 #8请获取字典中'k6'对应的值，如果'k6'不存在，则不报错，并且让其返回Nnoe
50
51 print(dic.get('k6'))
52
53 #9现有dic2 = {'k1':'v111','a':'b'}请通过一行操作使dic2 = {'k1':'v1','k2':'v2','k3':'v3','a':'b'}
54
55 dic = {'k1':'v1','k2':'v2','k3':'v3'}
56
57 dic2 = {'k1':'v111','a':'b'}
58
59 dic2.update(dic)
60
61 print(dic2)
62
63 #10.组合嵌套题，写代码，有如下列表，按照要求实现每一个功能
64
65 lis = [['k',['qwe',20,{'k1':['tt',3,'1']},89],'ab']]
66
67 #10.1.将列表lis 中的'tt'变成大写（用两种方式）
68
69 #10.1.1
70
71 print(lis[0][1][2].get('k1')[0].upper())
72
73 #10.1.2
74
75 print(lis[0][1][2].get('k1')[0].swapcase())
76
77 #10.2.将列表中的数字3 变成字符串'100'(用两种方式）
78
79 #10.2.1
80
81 print(lis)
82
83 lis[0][1][2].get('k1')[1] = '100'
84
85 print(lis)
86
87 #10.2.2
88
89 lis = [['k',['qwe',20,{'k1':['tt',3,'1']},89],'ab']]
90
91 dic3 = {'k1':['tt','100','1']}
92
93 print(lis)
94
95 lis[0][1][2].update(dic3)
96
97 print(lis)
98
99 #10.3 将列表中的字符串'1'变成数字101（用两种方式）
100
101 #10.3.1
102
103 lis = [['k',['qwe',20,{'k1':['tt',3,'1']},89],'ab']]
104
105 print(lis)
106
107 lis[0][1][2].get('k1')[2] = 101
108
109 print(lis)
110
111 #10.3.2
112
113 lis = [['k',['qwe',20,{'k1':['tt',3,'1']},89],'ab']]
114
115 dic3 = {'k1':['tt',3,101]}
116
117 print(lis)
118
119 lis[0][1][2].update(dic3)
120
121 print(lis)
122
123 #11 按照要求实现以下功能：
124
125 #现有一个列表li = [1,2,3,'a','b',4,'c']，有一个字典（此字典是动态生成的，你并不知道他里卖弄有多少键值对，所以
126
127 #用dic = {}模拟此字典）；现在需要完成这样的操作：如果该字典没有'k1'这个键，那就创建'k1'键和其对应的值(该键对应的值设置为空列表）
128
129 #并将列表li 中的 索引为奇数的对应元素，添加到'k1'这个键对应的空列表中。如果该字典有'k1'这个键，且'k1'对应的value
130
131 #是列表类型，那就将li中的索引为奇数的对应元素，添加到'k1'这个键对应的键中
132
133 dic = {'k2':2,'k3':3}#1. dic{}字典中 没有 'k1'
134
135 #dic = {'k1':['we','tt'],'k2':2}#2 dic{}字典中有'k1'
136
137 #dic = {'k1':1,'k2':33} # 有'k1'但'k1'value 非列表
138
139 li = [1,2,3,'a','b',4,'c']
140
141 if not 'k1' in dic:
142
143 dic.setdefault('k1',[])
144
145 for i in li :
146
147 if li.index(i) % 2 == 1:
148
149 dic['k1'].append(i)
150
151 else:
152
153 if type(dic['k1']) == type([]):
154
155 for i in li:
156
157 if li.index(i) % 2 == 1:
158
159 dic['k1'].append(i)
160
161 else:
162
163 print("字典K1,VALUE 不是列表，无法追加")
164
165 print(dic)6集合（set）
1 """
2 集合【无序可变】
3 作用：去重，关系运算
4 定义：
5 1：每个元素必须是不可变类型(可hash，可作为字典的key)
6 2:没有重复的元素
7 3：无序
8 4：可以包含多个元素，用逗号分割，
9 """
10 a = {1, 2, 3, 4, 5, 6, 7, 8, 9}
11 b = {1, 3, 9, 10, 11}
12
13 a.add(10) # 添加一个元素
14
15 a.discard(1) # 删除元素1，不存在的话不报错
16 a.remove(1) # 删除元素1，不存在的话报错
17 a.pop() # 随机删除
18
19 a.update([1, 8, 34]) # 更新，没有就添加，有就不添加
20
21 # 并集
22 a.uNIOn(b)
23 a | b
24 # 返回一个新的集合包含a和b的所有元素
25
26 # 交集
27 a.intersection(b)
28 a & b
29 # 返回一个新的集合包含a和b的公共元素
30
31 # 差集
32 a.difference(b)
33 a - b
34 # 返回一个新的集合，包含a中的元素，但是没有b中的元素
35
36 # 对称差集
37 a.symmetric_difference(b)
38 print(a ^ b)
39 # 返回一个新的集合包含 a和b中不重复的元素数据类型总结
- 【有序】: 列表，元组
- 【无序】: 字典，集合
- 【可变】:列表，字典，集合
- 【不可变】：数字，字符串，元组
- 【存单值】:数字，字符串
- 【存多值】:列表，元组，字典
四.格式化输出
利用占位符
%s就是代表字符串占位符，除此之外，还有%d,是数字占位符， 如果把上面的age后面的换成%d，就代表你必须只能输入数字啦；
%f小数 1 name = input('Name:')
2 age = input('Age:')
3 job = input('Job:')
4 hometown = input('Hometown:')
5
6 info='''
7 --------info of %s---------------
8 Name: %s
9 Age: %s
10 Job: %s
11 Hometown: %s
12 ------------end------------------
13 '''%(name,name,age,job,hometown)
14 print(info)
0