Python day-2
0. 基础数据类型宏观的开始
int：整型，加减乘除等计算。
str：字符串，存储少量的数据，进行简单的操作。
list：列表 [1,3,’st’,True…], 内容为各种数据类型，存储大量的数据。PY2可以存储上亿的数据。
tuple：元组，只读，存放大量数据。
dict：字典,{‘name’:’alex’}，查询速度快，存储关系型数据，基于二分查找。
set: 集合，测试两个集合的惯性。
bool：布尔值，True，False
1. 字符串
1) 单双引号配合使用：有的时候需要单双引号配合使用，如下面的例子，如果都为单引号，解释器会识别错误。
msg = “I’m Alex”
2) 字符串拼接，可以加，可以乘
s1 = ‘Alex’
s2 = ‘Shahe’
print(s1+s2)
print(‘jiangqiang’*8)
3) 索引与切片
索引从0开始，最后一位可以为-1
s = 'alexwusirritian'
s1 = s[0]-----取第一个字符
print(s1,type(s1))------ a <class 'str'>
s2 = s[-1]-------取最后一位n
s3 = s[-2]-------取倒数第二位a
切片顾头不顾尾
s5 = s[0:3]-----------取ale，取0,1,2，但不取3
s6 = s[0:4] -----------取alex
也可以省略0：s6 = s[:4] -----------取alex
s7 = s[4:9]-----取wusir
s8 = s[:]-------取全部alexwusirritian
切片与步长 s[起始索引:结束索引+1：步长]
s9 = s[:5:2]-------取0到4，但隔一个取一个，2为步长。取aew
s10 = s[-1:-5:-1]-----倒着取，nait
2. 格式化输出 占位符 % s（字符） %d（数字）
name = input('请输入名字：')
age = input('请输入年龄：')
job = input('请输入职业：')
hobbie = input('请输入爱好：')
msg = '''------------ info of %s -----------
Name : %s
Age : %d
job : %s
Hobbie: %s
------------- end -----------------
''' % (name, name, int(age), job, hobbie)
print(msg)
如果代码出现2%这样的百分比，可以使用%进行转义。
print('My name is %s,今年%d,学习进度2%%' %('oldboy',18))
3. 基本逻辑运算
and or not
1) 优先级 ()>not>and>or
2) 前后都是值 X or Y if X is True, return X. else, return Y.
3) X and Y If X is true, return Y. else, return X.
4) 0 是False，1是True
5) 解析下面：大于小于等判断符号优先于and or，有括号时，括号最优先。
print(1 > 2 and 3 < 4 or 4 > 5 and 2 > 1 or 9 < 8)
0 and 1 or 0 and 1 or 0
0 or 0 or 0
4. 字符串的常用方法
查看源代码方法，输入list，按住ctrl键
s = 'alexwusir'
s1 = s.capitalize()-----**首字母大写
s2 = s.swapcase()----**大小写翻转
s = 'alex wusir*taibai2ritian'
s3 = s.title()---*非字母隔开的每个单词的首字母大写 Alex Wusir*Taibai2Ritian
s = 'alexwusir'
s4 = s.center(30,)-----*设置总长度并居中
s4 = s.center(30,'*')---填充物为* **********alexwusir***********
s = 'alexWUSir'
s5 = s.upper()----**全部为大写 ALEXWUSIR
s6 = s.lower()----**全部为小写 alexwusir
#*** startswith endswith 以什么字符开始、以什么字符结束，可以设置匹配范围
s = 'alexWUSir'
s7 = s.startswith('a')-----返回True
s7 = s.startswith('x') -----返回False
s7 = s.startswith('alex') -----返回True，可以单个字符也可以多个字符
s8 = s.startswith('W',4,7)---在第4个和第6个字符之间，判断是否以W开头
s9 = s.endswith('r')----整个字符串以什么结尾
s9 = s.endswith('Sir')
#***strip默认去除字符串前后的空格，换行符，制表符
s = ' alexWUSir '
s10 = s.strip()----------alexWUSir
重点：一般用户输入用户名之后，用strip去除多余的空格，换行符
username = input('please input your name:').strip()
username = 'abcoldboyq'
ss1 = username.strip('abcq')------去除abcq
#* lstrip() rstrip() 去除左边去除右边，不常用
#***replace替换，可以填写替换的个数，如s12
s = 'alexbeijingalexshahe'
s11 = s.replace('alex','oldboy')-------- oldboybeijingoldboyshahe，默认全部替换
s12 = s.replace('alex','oldboy',1)------ oldboybeijingalexshahe，只替换第一个
#***split分隔，默认以空格分隔 str---->list
N个分隔符，N+1元素
s = 'alex wusir taibai ritian'
l = s.split()---------['alex', 'wusir', 'taibai', 'ritian']
l = s.split('m')------ m不存在 ['alex wusir taibai ritian']
l = s.split('a',2)----前两个a分隔 ['', 'lex wusir t', 'ibai ritian']
#***join list--->str 所有元素必须为字符串
s = 'oldboy'
s13 = '_'.join(s)--------- o_l_d_b_o_y
ll = ['alex' 'oldboy' 'wusir' 'taibai']
s14 = ' '.join(ll)-------- alexoldboywusirtaibai
#***find index 通过元素找索引，find找不到不会报错，index会报错
s = 'alexwusira'
s15 = s.find('e')-----返回索引2
s16 = s.find('ex')-----返回索引2
s17 = s.find('a')----返回第一个a的索引0
s18 = s.find('a',1)----返回第二个a的索引9
5. 格式输出format
第一种方法
s = 'my name is {}, age is {}, hobby is {}'
s21 = s.format('taibai', 18, 'game')---- my name is taibai, age is 18, hobby is game
第二种方法
s = 'my name is {0}, age is {1}, hobby is {2},english name is {0}'
s22 = s.format('taibai', 18, 'game')---- my name is taibai, age is 18, hobby is game,english name is taibai
第三种方法
s = 'my name is {name}, age is {age}, hobby is {hobby}'
s23 = s.format(age=18,hobby='game',name='taibai')------ my name is taibai, age is 18, hobby is game
6. 通用方法
name = '123'
print(name.isalnum()) #判断字符串由字母或数字组成 返回True
print(name.isalpha()) #判断字符串只由字母组成 返回False
print(name.isdigit()) #判断字符串只由数字组成 返回True
#字符串 整型 布尔值之间的转换
#字符串与整型之间的转换
str ---> int 字符串全部由数字组成 int('123')
int ---> str str(1)
#整型转化为布尔值
int ---> bool 0---> False 非0 ---> True bool(1)
print(bool(100))
print(bool(-1))
print(bool(0))
#布尔值转化为整型
bool --> int True 1 False 0
print(int(True))
print(int(False))
#字符串转化为布尔值
str ---> bool 非空 True 空字符串 False
print(bool(''))
print(bool('fdsaf'))
#布尔值转化为字符串
bool ---> str True—‘True’ False---‘False’
print(str(True),type(str(True)))
#字符串与列表之间的转化 split join
str ---> list split
list --> str join
7. 列表的操作
li = [1,2,3,4,5,6]
l1 = li[:3]-----返回索引0至2的元素[1, 2, 3]，返回为列表
l2 = [0]-----取索引0的值[0]，返回为列表
#增
l = ['wusir','alex','oldboy','barry']
1) 追加append
#追加字符串
l.append('景女神') ----['wusir', 'alex', 'oldboy', 'barry', '景女神']
#追加数字
l.append(1)---- ['wusir', 'alex', 'oldboy', 'barry', 1]
#追加列表
l.append([1,2,3])---- ['wusir', 'alex', 'oldboy', 'barry', [1, 2, 3]]
2) 插入insert
l.insert(2,'葫芦')---在索引2前面insert，['wusir', 'alex', '葫芦', 'oldboy', 'barry']
3) extend
l.extend('abc')---- ['wusir', 'alex', 'oldboy', 'barry', 'a', 'b', 'c']
l.extend([1,'test',56])---- ['wusir', 'alex', 'oldboy', 'barry', 1, 'test', 56]
#删
1) 按索引删除，pop
l.pop(1)--------返回删除的值
2）按内容删除 remove
l.remove('alex')
3) 清空列表clear
l.clear()-----列表被清空
4) 删除列表delete
A. 删除列表 delete l
B．按照索引删除 del l[1]
C. 切片删除 del l[:2]
#改
1) 按照索引修改
l[0] = 'ritain'------ ['ritain', 'alex', 'oldboy', 'barry']
2) 按照切片去修改
l[:3] = 'abcd'---- ['a', 'b', 'c', 'd', 'barry']
区域0到2被修改为a b c d
加步长修改必须一一对应
l[:3:2]=’ab’----步长为2，修改元素为2，可以
l[:3:2]=’abc’---步长为2，修改元素为3个，不可以
#查
#按照索引，切片（步长）
for i in l:
print(i)
#其它方法
len(l)-----总个数
l.count(‘wusir’)---------某个元素出现的个数，比如wusir出现的次数
#排序 sort
l1 = [1,9,8,4,3,5,6,2]
l1.sort()----正排序
print(l1)----- [1, 2, 3, 4, 5, 6, 8, 9]
l1.sort(reverse=True)---倒排序
#列表的嵌套
L1 = [1,2,’alex’,[‘wusir’,’taibai’,99],6]
8. 元组tuple
tu = (1, 2, 33, 'alex')
print(tu[1])------打印2
print(tu[:-1])----打印(1, 2, 33)
print(tu[:3]) ----打印(1, 2, 33)
#循环取得值
for i in tu:
print(i)
#元组的子值不能修改，但是子的子值可以修改，如，列表[1,3]可以修改
tu1 = (1,2,[1,3],4)
tu1[2].append(2)
9. Range 数字组成列表，其实没有元素
print(range(100))----返回range(0, 100)
#打印0到99
for i in range(100):
print(i)
#有步长的打印，打印2到100的偶数，范围是2到101，步长为2
for i in range(2,101,2):
print(i)
#倒着打印100到1
for i in range(100,0,-1):
print(i)
#与列表结合使用，按照索引打印列表里的元素
l1 = [1, 2, 3, 4, 5, 'alex']
for i in range(len(l1)):
print(l1[i])
10. 字典 key-value
通过键值对取值，存储关系型数据，二分查找，查找速度快。字典的键必须是唯一的，不可重复，value可以为任意数据类型或者对象。
PY3.5包括3.5版本以前都是无序的。
键只能是不可变的（也叫可哈希的）数据类型: int str tuple bool
可变的数据类型（不可哈希的）数据类型：dict,list,set
#增
dict[键]：有则更改，无则增加
dict = {
'name':'oldboy',
'age':18,
'sex':'male'
}
dict['hobby'] = 'game'
dict['name'] = 'alex'
print(dict)--- {'name': 'alex', 'age': 18, 'sex': 'male', 'hobby': 'game'}
setdefault:有不修改，无则增加
dict.setdefault('name', 'alex')
dict.setdefault('high', '175')
dict.setdefault('hobby')
print(dict)---- {'name': 'oldboy', 'age': 18, 'sex': 'male', 'high': '175', 'hobby': None}
#删除某个键值对
dict.pop('name')----无name键会报错
print(dict.pop('test','无此键'))-----返回值‘无此键’
dict.popitem()------随机删除
#clear 清除字典
dict.clear()
#删除delete
A. 删除整个字典 del dict
B. 按照键删除 del dict['name']，但无此键会报错。建议用pop。
#查
dict['name']----返回键对应的内容，若无此键会报错，建议用get
dict.get('name1')----无此键，默认返回none
dict.keys()#返回所有键值，不是列表，类似于列表的一个容器，可以for循环，但是无键值
print(dict.keys())----dict_keys(['name', 'age', 'sex'])
dict.values()#返回所有内容
print(dict.values())---dict_values(['oldboy', 18, 'male'])
dict.items()#返回所有键值及对应内容
print(dict.items())----dict_items([('name', 'oldboy'), ('age', 18), ('sex', 'male')])
#改
dict[‘name’] 有则修改，无则添加
dic2.update(dict)#将dict里面的键值对覆盖并更新到dic2里
dict = {"name": "jin", "age": 18,"sex": "male"}
dic2 = {"name": "alex", "weight": 75}
dic2.update(dict)
print(dict)----- {'name': 'jin', 'age': 18, 'sex': 'male'}
print(dic2)----- {'name': 'jin', 'weight': 75, 'age': 18, 'sex': 'male'}
#分别赋值
a,b = 1,3
print(a,b)---- 1 3
for k,v in dict.items():
print (k,v)
输出：name oldboy
age 18
sex male
11. 字典的嵌套及数据类型的补充
dic = {'name_list':['高猛', '于其',],
1:{
'alex': '李杰',
'high': '175',
}
}
# ['高猛', '于其',] 追加一个元素'wusir'，
dic['name_list'].append('wusir')
# {'alex': '李杰','high': '175' } 增加一个键值对 'sex': man，
dic[1]['sex'] = 'man'
##在循环一个列表时，不要改变列表的大小。#####
##在循环字典的时候，不要改变字典的大小。#####
#fromkeys的使用
dic = dict.fromkeys('abc',666)
print(dic)--- {'a': 666, 'b': 666, 'c': 666}
dic = dict.fromkeys('abc',[])
print(dic)--- {'a': [], 'b': [], 'c': []}
dic['a'].append(666)
print(dic)---- {'a': [666], 'b': [666], 'c': [666]} ，因为abc占用同一块内存