python基础---（变量、数据类型、在pycharm中查看源码）

python基础---（变量、数据类型、在pycharm中查看源码）***如何在pycharm中查看源码：
选中⽅法，Ctrl 加⿏标左键，即可打开⽅法的源码。

⼀、变量
1. 定义：把程序运⾏的中间结果临时的存在内存⾥，以便后续的代码调⽤。

2. 定义变量的原则：
1. 只能由数字、字母、下划线组成，数字不能开头（不能有特殊字符）；
2. 不能是python环境内的关键字
3. 变量的定义要具有可描述性。

4. 变量不能是中⽂。

5. 不可太长
3.Python中查看关键字的⽅法:1.import keyword 2.keyword.kwlist（获取所有关键字）
使⽤keyword模块查看python关键字；使⽤keyword.iskeyword()，来查看某⼀个是否
位关键字
常量
《：在Python中没有⼀个专门的语法代表常量，程序员约定俗成⽤变量名全部⼤写代表常量
AGE_OF_OLDBOY = 56》
定义⽅式：下划线(age_of_oldboy = 56)；和驼峰法(AgeOfOldboy = 56)
⼆、数据类型转换
1. int和bool数据类型转换：
int---->bool ⾮0即True
bool---->int True是1；Flase是0
2. int和str类型转换：
所有的int都能转换成str 123；’123’ 123=str('123')
只有纯数字组成的str，才能转化成int s=’123’ int(s)
3. str和bool类型的转换： #空list ,tuple ,dict的bool值都是False
str---->bool s = bool('')空字符串是False ; s = bool('qwe')是Ture。

bool---->str i = str(True/False) print(i,type(i)) ; 都是字符串。

4. 字符串的split⽅法，可以将str----->list
join（适⽤于str、列表、字典等可迭代对象）⽅法，可以将list等---->str
⽤字符串做⼀个连接符，链接可迭代对象中的每⼀个元素（每⼀个元素都必须是str：li = [1,'qwe']就会出错），形成⼀个新的字符串。

5.str与bytes类型的转换
str---->bytes encode⽅法；s.encode('utf-8')或('gbk')
bytes---->str decode⽅法；s.decode('utf-8')或('gbk')
6.元组与列表的转换
tuple--->list list(tuple)
list--->tuple tuple(list)
7.集合与列表的转换
set--->list list(set)
list--->set set(list)
三、数据类型
基础数据类型引⾔：
数据类型的分类：
可变数据型（不可hash）：list,dict.set　
不可变数据（可hash）：int,bool,str,tuple
容器类型：
容器类（承载各种数据类型）：list，tuple,dict
（⼀）int 运算。

+ - * / ** % ...
#bit_lenth ⽅法
i = 4
print(i.bit_lenth())
# 转化成⼆进制的最⼩位数。

（⼆）bool：判断，真假，作为条件
（三）str（字符串）存储少量的数据。

操作简单，便于传输。

1、str的索引与切⽚
（索引出来的数据，之前是什么类型，索引出来还是原来的类型；
切⽚形成的数据，对谁（list，str，tuple）进⾏切⽚，之后还是
原先（list，str，tuple）的数据类型）
a.字符串的拼接
字符串可以进⾏相加和相乘
b.字符串在内存中的存储
n="oldboy" 如果是汉字，编码不同，则占⽤的字节不同。

⼀个字母会占⽤⼀个字节，最后加⼀个'\o'；即n⼀共占⽤8个字节。

()
c.字符中的下标，索引
n="oldboyOLDBOY" 下标是⽤0开始；n[0]的输出是"o";n[-1]的输出是"Y"
d.字符串的切⽚、逆序
[索引初值:索引终值:步长] （默认的步长是1）（原则就是顾头不顾尾）
n[1:4] 的输出是“ldbo”
n[2:]第⼀个：后⾯什么都不写，会取到最后⼀个字符；输出的是：“dboyOLDBOY”
n[2:-1:2]步长=2，跳⼀个，取⼀个；输出的是：“doODO”
n[::-1]表⽰逆序，起始值什么不写，可能是第⼀个也可能是倒数第⼀个；如果步长是-1就表⽰逆序。

输出的是：“YOBDLOyobdlo”。

2、字符串（str）的使⽤⽅法 (通过查看源码，学习其他⽅法)
1.captalize(⾸字母⼤写)；title(每个单词⾸字母⼤写)
2 ps:
3 s = 'laonahai'
4 print(s.captalize())
5
6 s = 'lao nan,hai7is' (以空格数字特殊符号⾮字母认为是分开的单词)
7 print(s.title())
8
9 2.upper(全部⼤写)；lower(全部⼩写)
10 s = 'laonahai'
11 print(s.upper())
12
13 s = 'laonahai'
14 print(s.lower())
15
16 3.swapcase(⼤⼩写翻转)
17 s = 'laOnaHai'
18 print(s.swapcase())
19
20 4.center(20,"$")内容居中，总长度，空⽩处填充
21 s = 'laonahai'
22 print(s.center(25,"*"))
23
24 5.startswith(判断以什么开头)；endswith(判断以什么结尾)
25 s = 'laonahailaonahai'
26 print(s.startswith('l')
27 ()内的参数必须是⼀个整体，不能调隔；可以传切⽚（start和end）参数。

28
29 6.strip(去除⾸尾的空格，/n ,/t) lstrip(去除左边的) rstrip(去除左边的)
30 s = ' \n laonahai \t '
31 print(s.strip())
32
33 7. find(通过元素查找索引)；找不到时会返回⼀个"-1"
34 index(通过元素查找t(s.startswith('l')
35 s = 'laonahailaonahai'
36 print(s. find('l',1,9) 可以传切⽚（start和end）参数。

37 8.count(寻找元素出现的个数，可切⽚)
38 s = 'laonahailaonahai'
39 print(s.count('l',3,12)
40 9.replace(替换)
41 s = 'laonahailaonahai'
42 print(s.count('l','m')
43 10. split 分割 str ---> list
44 s = 'alex wusir taibai'
45 print(s.split())
46 s1 = 'alex,wusir,taibai'
47 print(s1.split(','))
48 s2 = 'alexawusirataibai'
49 print(s2.split('a'))（会把a⼲掉）
50 s3 = 'alexawusirataibai'
51 print(s3.split('a',1)) # 分割次数
52
53 11.format(格式化输出)
54 三种⽤法
55 第⼀种⽤法：
56 s = '我叫{}，今年{}，爱好{}'.format('MT',18,'母⽜')
57 print(s) **{}中间不能有空格，否则报错
58 第⼆种⽤法
59 s = '我叫{0}，今年{1}，爱好{2}，我依然叫{0},今年还是{1}'\
60 .format('MT',18,'母⽜') **{}内的数字依据format()内的个数来填写；在这⾥不能超过2，填3就会报错。

61 print(s)
62 第三种键值对
63 s = '我叫{name}，今年{age}，爱好{hobby}'.format(age=18, name='MT', hobby='闷⼉')
64
65 12.isalnum,isalpha,isdigit
66 name='123a'
67 print(name.isalnum()) #字符串由字母或数字组成
68 print(name.isalpha()) #字符串只由字母组成
69 print(name.isdigit()) #字符串只由数字组成
70 if name.isdigit():
71 name = int(name)
72 print(name,type(name))
73 else:
74 print('您输⼊的由⾮数字元素')
View Code
rsplit 从右侧开始分割
isalnum:判断str是否由字符和数字，混合组成； 设置密码必须有数字，字母，特殊字符，如何判断srt中是否含有特殊字符？？ 答（⽤re）isspace：判断str是否是空格
strip(),可以传参数：指定的⼀个元素，把这个元素过滤掉
strip()的注意点：
（四）list 列表存放⼤量的数据，⼤量的数据放在列表中便于操作。

⽽且列表有序，有索引值，可切⽚，⽅便取值
A.列表定义：
⽅法⼀：names = [1，2，"qwe"，{"name":"⽼男孩"},[3.14，55,66]]
⽅法⼆：names = list('qwer') 迭代的添加⽅法；会⽣成这样⼀个列表 ['q', 'w', 'e', 'r']
⽅法三：names = list(['qwer',8,9,7])
B.增删改查：
1复制代码
2增：
3 1.append：⼀次只能添加⼀个，追加到最后⼀个元素。

4 2.insert：指定索引位置添加，⼀次只能添加⼀个元素。

5 3.extend：迭代的添加，到列表最后。

6删：
7 pop：按照索引值删除，⼀次只能删除⼀个，
8 remove：按照元素删除，⼀次只能删除⼀个。

9 clear：清空列表
10del list：删除列表 /del list[索引值]可切⽚。

11改：
12 1.[索引值] = new，通过索引赋新值。

13 2.[切⽚] = new，通过切⽚的改回迭代的条件到列表中。

14查：
15 1.[]索引或切⽚查
16 2.循环查
17
18补充：
19in not in判断列表中是否存在该元素。

20复制代码
list增删改查
删的pop和remove⼀侧只能删除⼀个；切⽚删除⽤ del list[:]
C.列表的⽅法：
可以索引值，切⽚，步长，
其他操作⽅法：
1，sort 从⼩到⼤，正向排序
l1 = [1, 2, 1, 7, 5, 4, 9, 8, 3]
l1.sort()
2，从⼤到⼩，反向排序
l1.sort(reverse=True)
3.翻转 #str或int类型都可以
l1.reverse()
4.len 长度 len(l1)
5.index 通过元素找索引；(列表只有index⽅法；没有find⽅法。

)
D.列表的嵌套：列表再有列表
li = [1,2,'alex',['100','wusir',99,[44]],22]
li = [1,2,'alex',['100','wusir',99],22]
li[2] = li[2].capitalize()
#print(li)
li[3][1]=li[3][1].upper()
print(li)
li [3][2] = 99+1
print(li)
列表嵌套查询的⽅法：li.[索引值][索引值]
列表嵌套⽰例
E.在循环⼀个列表是，最好不要进⾏删除操作，（⼀旦删除，索引会随之改变，容易出错）
eg：li = [11,22,33,44,55]将索引为奇数的元素删除。

⽅法1：⽤切⽚删除
del li[1::2]
⽅法2：定义⼀个空列表，for循环出每⼀个奇数元素，添加到空列表中，再赋值给原先的列表。

li = [11,22,33,44,55]
l2 = []
for i in range(len(li)):
if i%2==0:
l2.append(li[i])
li = l2
⽅法3：倒序删除
for i in range(len(li)-1,-1,-1):
if i %2 == 1:
del li[I]
备注：列表中不使⽤多⾏注释
（五）tuple 元组只读列表。

(1,2,{"name":"⽼男孩"})数据可以被查询，不能被修改。

所以，字符串的切⽚同样适⽤于元组。

A.创建：ages = ()
ages = tuple(())
⼉⼦不能改，孙⼦可以改：如果元组中有列表、字典等，可以修改的元素，那么列表等可以进⾏修改。

B.常⽤操作：
索引，切⽚，循环，长度，包含（in not in）
C.对于元组：如果只有⼀个元素，并且没有逗号 ；t = (2) <==>t = 2
此元素是什么数据类型，该表达式就是什么数据类型。

　t = (2,)　则是⼀个元组
（六）dic 字典存储关系型的数据，查询速度⾮常快，⼆分查询。

A.字典的定义：python对key进⾏哈希函数运算，根据计算的结果决定value的存储地址，所以字典是⽆须存储，（3.5之前；3.6以后的版本，字典在创建的时候，按照⼀定的顺序插⼊的数值，看起来是有序的。

）
B.列表是有序的对象集合，字典是⽆须的对象集合，两只之间的区别在于：
字典当值的元素是通过键来存储，⽽不是通过偏移存储。

创建：info = {key1:value1,key2:value2}
1.键与值⽤“:”冒号分开
2.项与项⽤“,”号分开
创建⽅法：1.person = {'name':'les','age',18}
2.person = dict(name='les','age'=19)
3.preson = dict({'name':'les','age',18})
4.dic = dict([("k1", "v1"), ("k2", "v2")]) 有序字典：OrderedDict([("k1", "v1"), ("k2", "v2")])
特性：
1.key-value结构
2.key必须可hash，且必须为不可变类型，必须唯⼀
3.可存放任意多个值，可修改，可以不唯⼀。

4，⽆序。

（3.5之前；3.6以后的版本，字典在创建的时候，按照⼀定的顺序插⼊的数值，看起来是有序的。

）
info= {"name":"班长"，"addr":"⼭东"，"age":18}
print("%s %d %s"%(info["name"],info["addr"],info["age"]))
注意：
c.增删改查：
1增：
2
3 第⼀种：给key赋value（有则覆盖，⽆责添加）
4
5 dic['key'] = 'value'
6
7 第⼆种：.setdeafult（有则不变，⽆责添加）
8
9 dic.setdefault()
10
11 删：
12
13 第⼀种：.pop() 有返回值的
14
15 dic.pop('key') 根据key删除键值对，并返回对应的值，如果没有key则返回默认返回值。

eg：print(dic.pop('na','没有此键')) 如果dic中没有'na'这个值，后⾯可以再⾃⼰定义⼀个参数，提⽰出，没有'na'这个key值对。

16
17
18 第⼆种：.popitem() 随机删除，有返回值。

19 dic.popitem()
20 第三种:.clear　清空
21 dic.clear
22 第四种：del 删除字典；也可以带⼊key,删除键值对
23 del dic
24 del dic['key']
25 改:
26 第⼀种:给key赋value（有则覆盖，⽆责添加）
27 dic['name'] = '太⿊'
28 第⼆种：.update⽅法 两个字典的改，
29 dic = {"name":"jin","age":18,"sex":"male"}
30
31 dic2 = {"name":"alex","weight":75}
32
33 dic2.update(dic) # 将dic所有的键值对覆盖添加（相同的覆盖，没有的添加）到dic2中
34 查：
35
36 第⼀种:print(dic['name']) 通过key来查看，value
37
38 第⼆种：.get⽅法
39
40 print(dic.get('name1')) # 默认返回None
41
42 print(dic.get('name1','咩有此键值对')) # 默认返回None
View Code
dict的键值对增加⽅式，有则覆盖：添加key，value时，字典中有相同的key；则会把原key对应的value值覆盖。

popitem，删除，返回的元组形式的键值对。

pop('key',"没有此键") 当key不存在时，不加参数，则报错；设置参数，则返回设置的参数；（可以设置⼀个“没有此键”的参数）
D.其他⽅法：
1.keys() values() items()
print(dic.keys())
#for i in dic.keys: #<==>for i in dic:
print(i)# 循环key
keys = dic.keys()
print(keys,type(keys))
dict_keys(['sex', 'age', 'name']) <class 'dict_keys'>特殊的字典类列表。

print(dic.vaules())
......
dic.items() key.value都打印出来
2.字典的 fromkeys(*args, **kwargs)⽅法： *args必须是⼀个可迭代对象。

dic = dict.formkeys('abc','alex') #会把abc迭代的添加到字典中，对应的每⼀个值都是'alex'
dic = dic.formkeys([1,2,3],[]) #先⽣成{'1':[],'2':[],'3':[]}
dic[1].append('⽼男孩') #再分别把'⽼男孩'添加到每⼀个字典的值中。

dic[1] = 777 #则改变的只有dic[1]的值是777；其他都是'⽼男孩'
v = dict.fromkeys(['k1','k2'],[])
v[‘k1’].append(666)
print(v){'k1': [666], 'k2': [666]}
v[‘k1’] = 777 # 单独对k1进⾏赋值
print(v){'k1': 777, 'k2': [666]}
循环键值对
1.for i in dic.items:
2.for k,v in dic.items():
3.　for i in dic:
print(i) print(k,v) print(i,dic[i])
2.长度：len(dict)　
E.字典的嵌套
dic = {"name_list":['张三','lisi','隔壁王叔叔'],'dic2':{'name':'太⽩','age':12}}
1 ,给列表追加⼀个元素：'旺旺'
dic['name_list'].append('旺旺')
2,给列表lisi全部⼤写
dic['name_list'][1] = dic['name_list'][1].upper()
3，给dic2 对应的字典添加⼀个键值对：hobby：girl
dic['dic2']['hobby'] = 'girl'
dic['dic2'].setdefault('hobby','girl')
F.在循环字典中，不能增加或删除此字典的键值对。

(字典中不能有重复的key，循环添加会被覆盖)
eg：dic = {'k1':'value1','k2':'value2','name':'wusir'}
将字典中含有k元素的键，对应的键值对删除。

解决⽅法：把包含K元素的键，添加到列表中；再循环列表时，删除键值。

li = []
for i in dic:
if'k'in i:
li.append(i)
for i in li:
del dic[i]
print(dic)
代码1
for i in list(dic):
if'k'in i:
del dic[i]
print(dic)
代码2
set 集合交集，并集，补集...
集合是⽆序的，不重复的数据集合，它⾥⾯的元素是可哈希的(不可变类型)，但是集合本⾝是不可哈希（所以集合做不了字典的键） 但是：frozenset不可变集合，让集合变成不可变类型。

也就可以做字典的key了。

frozenset转换之后，⾥⾯的还是⽆序的({'a', 'y', 'b', 'r'})
s = frozenset('barry')
print(s,type(s)) # frozenset({'a', 'y', 'b', 'r'}) <class 'frozenset'>
集合的两个重要应⽤：
1.去重，把⼀个列表变成集合，会⾃动去除列表的重复元素；
2.关系测试，测试两组数据之间的交集，差集，并集等关系。

1.集合的创建、形式
创建⼀个空集合必须⽤ set() ⽽不是 { }，因为 { } 是⽤来创建⼀个空字典。

　
有元素集合set 1= {1,2,3}
2.集合的增
set1.add()
set1 = {'alex','wusir','ritian','egon','barry'}
set1.add('景⼥神')
print(set1)
set1.update()
set1.update('abc')
# set1.update([1,2,3])
# print(set1)
3.集合的删
set1 = {'alex','wusir','ritian','egon','barry'}
set1.remove('alex') # 删除⼀个元素
print(set1)
set1.pop() # 随机删除⼀个元素
print(set1)
set1.clear() # 清空集合
print(set1)
del set1 # 删除集合
print(set1)
set1.discard('alex') <==> remove
4.集合的其他操作
4.1 交集。

（& 或者 intersection）
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 & set2) # {4, 5}
print(set1.intersection(set2)) # {4, 5}
4.2 并集。

（| 或者 union）
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 | set2) # {1, 2, 3, 4, 5, 6, 7}
print(set2.union(set1)) # {1, 2, 3, 4, 5, 6, 7}
4.3 差集。

（- 或者 difference）
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 - set2) # {1, 2, 3}
print(set1.difference(set2)) # {1, 2, 3}
4.4反交集。

（^ 或者 symmetric_difference）
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 ^ set2) # {1, 2, 3, 6, 7, 8}
print(set1.symmetric_difference(set2)) # {1, 2, 3, 6, 7, 8}
4.5⼦集与超集
set1 = {1,2,3}
set2 = {1,2,3,4,5,6}
print(set1 < set2)
print(set1.issubset(set2)) # 这两个相同，都是说明set1是set2⼦集。

print(set2 > set1)
print(set2.issuperset(set1)) # 这两个相同，都是说明set2是set1超集。

集合set的查询：集合是⽆许的，只能通过循环的⽅式查询。