python数据类型和变量
1.python文件的后缀名为 *.py
2.两种执行方式：
python解释器 py文件路径
python 进入解释器：
实时输入并获取到执行结果
3.在Linux下，文件名和文件内部与windows有所不同
文件名
./*.py
文件内部：
开头得加上 #/usr/bin/env python （声明一下是用哪个python解释器）
4.python2与python3的不同
python2默认的ASCII码编码，只能编码英文而不能对中文编码，当语句中出现中文时，
运行会报错，得在文件内部开头加上 # -*- coding：utf8 -*-，才能避免报错。
python3无需关注编码。
5.编码方式
ASCII-8位
eg: &--00100110
UNICODE-16位+
eg: &--0000000000100110 (浪费内存）
utf8-能用多少位表示就用多少位
eg: &--00100110
6.变量名只能由字母、数字、下划线组成。（不能用数字开头 ）
python关键字也不能用于变量名。
7.条件语句
1).if 条件：
（Tab键）代码块
else：
（Tab键）代码块
2). if 条件：
（Tab键）if 条件：
（Tab键）代码块
else：
（Tab键）代码块
else：
（Tab键）代码块
3).if 条件：
（Tab键）代码块
elif 条件：
（Tab键）代码块
elif 条件：
（Tab键）代码块
...
else：
（Tab键）代码块
4).当满足某条件不需要执行任何操作时
eg: if 1===1 ：
pass
else：
print("sb")
8.字符串（引号）：
name = "我是索得"
name = '我是索得'
name = """我是索得"""
name = '''我是索得'''
#加法：
n1 = "chen"
n2 = "jian"
n3 = n1+n2
n3 = "chenjian"
#乘法：
n1 = "chen"
n2 = 5*n1
n2 = "chenchenchenchenchen"
9.运算符
+ - * / **（指数计算，如10**3表示10的3次方）
% //（取商）
in not in （某个东西是否在另一东西里面）
布尔值
True
false
结果是值
算术运算
a=10*10
a=a+1 a+=1
结果是布尔值
比较运算
a=1>5
逻辑运算
a=1>6 or 1==1
成员运算
a='邹’ in '邹雨晴'
10.基本数据类型
数字
-int
将字符串转换为数字
a="123"
print(type(a),a) #输出a的类型、a
b=int(a) #将字符串类型转换为数字类型
print(type(b),b) #输出b的类型、b
num="0011"
v= int (num,base=16) #将0011转换为16进制
print v
*.bit_lenght
a=7
r=a.bit_lenght() #当前数字的二进制，至少用n位表示
字符串
-str
m = "chen"
n = "jian"
print(m + n) #输出为：chenjian
*.capitalize() #将首字母大写,首字母除外小写
text = "CHEN"
v1 = text.capitalize()
print(v1)
*.casefold() #转换成小写
text = "CHEN"
v2 = text.casefold()
*.lower() #转换成小写
v3 = text.lower()
print(v3)
*.islower() #判断是否全部是小写，小写返回值为真，否则为假
text = "CHEN"
s1 = text.lower()
*.upper() #转换成大写
text = 'lebron'
s2 = text.upper()
*.isupper() #判断是否全部是大写，大写返回值为真，否则为假
text = 'Lerbron'
s3 = text.isupper()
*.center() #设置宽度并将内容居中，20指代总长度，"#"在空白位置填充，只能为一个字符，并且它可有可无
text = '湖人总冠军'
v4 = text.center(20,"#")
print(v4)
*.count() #去字符串中寻找子序列出现的次数,后面的参数可以设置为起始位置和结束位置，这两数字参数可有可无
text1 = "chenchen"
v5 = text1.count('e', 5, 6)
print(v5)
*.endswith() #判断是否以指定字符结尾，若是则返回值为真
text1 = 'chen'
v6 = text1.endswith('en')
print(v6)
*.startswith() #判断是否以指定字符开头，若是则返回值为真
text1 = 'ensure'
v7 = text1.startswith('en')
print(v7)
*.find() #从开始往后找，找到第一个为止，返回其位置的索引值，数字参数表示从某个位置找到某个位置，数字参数可有可无
text1 = 'eneneenen'
v8 = text1.find('en', 5, 8)
print(v8)
# v8=text1.index('en') 也是找字符，但未找到就会直接报错，不常用
*.format() #模式化，将一个字符串中的占位符替换为指定值
text2 = 'i am {name},{age}'
v9 = text2.format(name='chen', age='22')
print(v9)
text3 = 'i am {0},{1}'
v10 = text3.format('chen', '22') # 模式化的另外一种方法，0和1表示在format中的位置
*.format_map() #模式化的第三种方式
text2 = 'i am {name},{age}'
v11 = text2.format_map({"name": 'chen', "age": 22})
print(v11)
*.isalnum() #字符串中是否只包含数字和字母，返回值为布尔值
text4 = 'areyon23'
v12 = text4.isalnum()
print(v12)
*.expandtabs() #制表
s1="usrname\tmail\tpasswd\nchen\t465116388@qq.com\t136136\nzou\t15874159563@qq.com\t123123"
v = s1.expandtabs(20)
print(v, len(v))
>>>
usrname mail passwd
chen 465116388@qq.com 136136
zou 15874159563@qq.com 123123
*.isalpha #只包含字母或者汉字时，返回值为真，否则为假
test1 = "846"
t = test1.isalpha()
print(t)
*isidentifier() #只包含字母、数字、下划线及其组合，并且首位不是数字时，返回值为真，否则为假
test2 = "s1_56"
s = test2.isidentifier()
print(s)
*.isdigit *.isdecimal *.isnumeric
test3="1236"
v1 = test3.isdigit() #只包数字时，返回值为真，否则为假
v2 = test3.isdecimal() #只包数字时，返回值为真，否则为假 (最常用)
v3 = test3.isnumeric() #只包数字（中文数字和圈数都行）时，返回值为真，否则为假
print(v1, v2, v3)
*.isprintable #包含不可显示的字符时，返回值为假，否则为真
test4 = "dasfj\tasfl"
v4 = test4.isprintable()
print(v4)
*.isspace() #只包含空格时，返回值为真，否则为假
v5 = test4.isspace()
print(v5)
*.istitle() #为标题时(每个单词的首字母都是大写)返回为真,否则为假
test5 = "Hello my name is Chen"
v6 = test5.istitle()
print(v6)
*.title() #将字符串变成标题的形式
v7 = test5.title()
print(v7)
*.join #将字符串中的每一个元素按指定的分隔符连接 (重要)
test6 = "湖人总冠军"
print(test6)
t = '_'
v8 = t.join(test6)
print(v8)
*.ljust *.rjust *.zfill
test7 = "lebronjames"
v9 = test7.ljust(20, '*') #在字符串的后面用指定的字符填充为指定的长度
v10 = test7.rjust(20, '*') #在字符串的前面面用指定的字符填充为指定的长度
v11 = test7.zfill(20) #在字符串的前面用0填充为指定的长度
print(v9)
print(v10)
print(v11)
>>>
lebronjames*********
*********lebronjames
000000000lebronjames
*.rstrip *lstrip *strip
test8 = "\t\tchenjian\t\t "
v12 = test8.rstrip() #去除右边空格、\t、\n，也可以在括号中指定字符来去除
v13 = test8.lstrip() #去除左边空格、\t、\n，也可以在括号中指定字符来去除
v14 = test8.strip() #两边空格都去除、\t、\n，也可以在括号中指定字符来去除
print(v12)
print(v13)
print(v14
>>>
chenjian
chenjian
chenjian)
*.maketrans #指定字符进行替换
test9 = "火箭总冠军" m = str.maketrans("火箭", "湖人") v14 = test9.translate(m) print(v14)
>>>
湖人总冠军
*.replace #指定字符进行替换，后面的数字表示替换的个数
n = test9.replace("火箭", "湖人", 1)
print(n)
*.partition() *.rpartition
test10 = "湖人是总冠军，詹姆斯是FMVP"
v15 = test10.partition('是') #从左至右指定某一字符对字符串进行分割
v16 = test10.rpartition('是') #从右至右指定某一字符对字符串进行分割
print(v15)
print(v16)
*.split() #从左至右指定某一字符对字符串进行分割，分割后的字符串不包含该指定的字符,括号中的数字可以指定分割的次数，不加数字时，默认 从头到尾进行分割
v17 = test10.split('是', 1)
print(v17)
*splitlines() #根据换行符进行分割，括号中的参数为true或者false，为true时保留换行符，为false时去掉换行符
test11 = "湖]人\n是他妈的\n总冠军\n"
v18 = test11.splitlines()
print(v18)
*.startswith() *.endswith()
test12 = "詹姆斯是联盟第一人"
v19 = test12.startswith('詹') #判断字符串开头是否以指定字符开始，若是则返回值为true，否则为false
v20 = test12.endswith('人') #判断字符串结尾是否以指定字符结束，若是则返回值为true，否则为false
print(v19, v20)
*.swapcase() #大写转换成小写，小写转换成大写
test13 = "cHEN jIAN "
v21 = test13.swapcase()
print(v21)
#必须记住的功能： join split find upper lower replace
test14 = "chen"
v22 = test14[0] #获取字符串中的某一个字符，中括号里面的参数表示获取字符的位置
print(v22)
v23 = test14[0:2] #获取字符串中的某一个字符,并且指定获取字符的位置范围
print(v23)
test15 = "詹姆斯将会在总决赛中夺得FMVP"
count = 0
while count < len(test15):
v24 = test15[count]
print(v24)
count += 1
for lbj in test15: #for循环
print(lbj)
v25 = range(0, 100, 5) #生成大于等于0且小于100的
for item in v25:
print(item)
列表
-list
li = [1,12,"chen",[1,89],true]
中括号括起来，逗号分割每个元素
列表中的元素可以是数字，字符串，列表，元祖，布尔值。。。
列表支持in操作
列表元素可以被修改、增加或删除
可以通过索引或者切片的方式取值
li = [1,12,"chen",[1,89],true]
li[1] = 0 #索引修改
print(li) #输出为：li = [1,0,"chen",[1,89],true]
li[1:3] = [120,90] #切片修改
print(li) #输出为：li = [1,120,90,[1,89],true]
可以增加
li = [1,12,"chen",[1,89],true]
li[1] = [12,6,98]
print(li) #输出为：li = [1,12,6,9,"chen",[1,89],true]
可以删除：
li = [1,12,"chen",[1,89],true]
del li[1] #索引删除
print(li) #输出为：li = [1,"chen",[1,89],true]
del li[1:4] #切片删除
print(li) #输出为：li = [1,true]
对列表中列表的元素进行索引取值
li = [1,12,"chen",[1,89],true]
li[3][0] == '1'
li[2][0] == 'c'
字符串转列表
s = "asdlfjasld"
li = list(s) #字符串中每一个字符转换成列表中的元素
列表转字符串
1).列表中既有数字又有字符串时，需要自己写一个for循环
li = [1,12,"chen",[1,89],true]
s = ''
for i in li :
s += str(i)
print(s) #输出为：112chen[1, 89]True
2).列表中只有字符串
li = ["chen", "jian", "zou"]
t = ''
v = t.join(li)
print(v) #输出为:chenjianzou
数字不能迭代，所以不能转换成列表
*.append #在原列表最后加一个元素，当追加元素是列表时，将追加的元素看成一个整体加入
li = [11, 22, 33, 44]
li.append(5)
print(li) #输出为：[11, 22, 33, 44, 5]
*.clear #清空
li = [11, 22, 33, 44]
li.clear()
print(li) #输出为：[]
*copy #拷贝，浅拷贝
li = [11, 22, 33, 44]
v = li.copy()
print(v) #输出为[11, 22, 33, 44]
*.count #计算指定元素的个数
li = [11, 22, 33, 44]
v = li.count(22)
print(v) #输出为：1
*.extend #扩张列表，参数是可迭代对象
li = [11, 22, 33, 44]
li.extend("chen") 输出为：#[11, 22, 33, 44, 'c', 'h', 'e', 'n']
li.extend([9898, "chen"]) 输出为：#[11, 22, 33, 44, 9898, 'chen']
print(li)
*.index #根据指定值获取其索引位置（从左至右），参数1表示指定值，参数2表示起始位置，参数3表示结束位置（获取的是绝对位置）
li = [11, 22, 33, 44]
v = li.index(22, 0, 5)
print(v) #输出为：1
*.insert # 在指定索引位置插入元素
li = [11, 22, 33, 44]
li.insert(0,99)
print(li) #输出为：[99, 11, 22, 33, 44]
*.pop() #默认删除最后一个，加入索引可以删除指定值，并且获取删除值。可以理解为弹出列表的最后一个值
li = [11, 22, 33, 44]
v = li.pop()
print(li) #输出为：[11, 22, 33]
print(v) #输出为：44
*.remove #删除列表中的指定值，左边优先
li = [11, 22, 33, 44]
li.remove(33)
print(li) #输出为：[11, 22, 44]
del *[]
li = [1, 12, "chen", [1, 89], True]
del li[1 ] # 索引删除
print(li) # 输出为：li = [1,"chen",[1,89],true]
del li[1:3] # 切片删除
print(li) # 输出为：li = [1,true]
*.reverse #将当前列表进行反转
li = [11, 22, 33, 44]
li.reverse()
print(li) #输出为：[44, 33, 22, 11]
*.sort() #列表的排序
li = [11, 33, 22, 44]
li.sort() #从小到大排序
print(li) #输出为: [11, 22, 33, 44]
li.sort (reverse=True) #从大到小排序
print(li) #输出为：[44, 33, 22, 11]
元组 （不可改变的列表）
-tuple
元祖中一级元素不可被修改、增加或者删除
元祖中的元素可以是数字，字符串，列表，元祖，布尔值。。。
元祖是有序的，可以通过索引或者切片的方式取值
可以被for循环，是可迭代对象
字符串、列表、元祖之间的相互转换
s = "chenjian"
li = ["chenjian", 23]
tu = (136, 136, "chen")
u = tuple(s)
v = tuple(li)
w = str(tu)
x = list(tu)
print(u) # ('c', 'h', 'e', 'n', 'j', 'i', 'a', 'n')
print(v) #('chenjian', 23)
print(w) #(136, 136, 'chen')
print(x) # [136, 136, 'chen']
*.count() #指定元素的个数
tu = (136, 136, "chen")
v = tu.count(136)
print(v) # 1
*.index() #获取指定元素的索引位置（从左至右）
tu = (136, 158, 136, "chen")
v = tu.index(136, 1, 3)
print(v) # 2
*.enumerate()
tu = ('alex', 'eric', 'rain')
for item, ele in enumerate(tu, 10): #enumerate()括号中不加数字时，默认从0开始。
print(item, ele)
输出为：10 alex
11 eric
12 rain
字典
-dict
info = {"k1":1, "k2":True, "chen":"jian", (11, 22,):[1, 2], "k3":{"kk1":1, "kk2":2}}
字典的value可以是任何值
列表，字典不能作为字典的key
字典是无序的，不能通过切片的方式获得值，只能通过索引取值 info["k1"]为1
字典的value可以被删除和修改
字典可以进行for循环，默认是对key进行循环，也可以指定对value或者键值对进行循环
info = {
1:123
"k1":1,
"k2":True,
"chen":"jian",
(11, 22,):[1, 2],
"k3":{"kk1":1, "kk2":2}
}
for item in info: #对key进行循环，输出key的值
print(item)
for item in info.keys(): #对key进行循环，输出key的值
print(item)
for item in info.values(): #对value进行循环，输出value的值
print(item)
for item in info: #对key进行循环，输出键值对
print(item, info[item])
for k,v in info.items(): #对键值对进行循环，输出键值对
print(k,v)
dict.fromkeys # 根据序列创建字典，并指定统一的值
v = dict.fromkeys(["chen", "jian", 1], 136)
print(v) # {'chen': 136, 'jian': 136, 1: 136}
*.get() # 根据key获取值，key不存在时，可以指定默认值（None）
info = {
"k1": 1,
"k2": True,
"chen": "jian", (11, 22,): [1, 2],
"k3": {"kk1": 1, "kk2": 2}
}
v = info.get('k1')
print(v) # 1
*.pop # 删除指定的key，并且可以获取被删除key所对应的value值
info = {
"k1": 1,
"k2": True,
"chen": "jian",
(11, 22,): [1, 2],
"k3": {"kk1": 1,
"kk2": 2}
}
v = info.pop("k1")
print(info, v) # {'k2': True, 'chen': 'jian', (11, 22): [1, 2], 'k3': {'kk1': 1, 'kk2': 2}} 1
*.popitem # 随机删除一个键值对，并且可以获取被删除的键值对
info = {
"k1": 1,
"k2": True,
"chen": "jian",
(11, 22,): [1, 2],
"k3": {"kk1": 1,
"kk2": 2}
}
k, v = info.popitem()
print(info, k, v) # {'k1': 1, 'k2': True, 'chen': 'jian', (11, 22): [1, 2]} k3 {'kk1': 1, 'kk2': 2}
*.setdefault # 设置值，如果设置key已经存在，则不设置，可获取当前值：若设置的key值不存在，则将设置的键值对加入字典，并获取当前可以 对应的值
info = {
"k1": 1,
"k2": True,
"chen": "jian",
(11, 22,): [1, 2],
"k3": {"kk1": 1, "kk2": 2}
}
v = info.setdefault("k111", "136")
print(info, v)
*.update # 更新，指定键值对存在则覆盖，不存在则添加
info = {"k1": 1,
"k2": True,
"chen": "jian",
(11, 22,): [1, 2],
"k3": {"kk1": 1, "kk2": 2}
}
info.update({"k1": "111222", "k5": 123456}) # info.update(k1 = 123, k5 = 123456))
print(info)
10.集合
set
l1 = [1, 2, 3]
l2 = [2, 3, 4]
print(set(l1)&set(l2))
print(set(l1)|set(l2))
输出：
{2, 3}
{1, 2, 3, 4}
11.数据类型和变量总结
数字
字符串
列表
元组
字典
可变与不可变：
1.可变：数组、字典 （对其中的元素重新赋值后不会开辟新的内存空间）
2.不可变：字符串、数字、元组 （对变量名重新赋值后会开辟新的内存空间）
访问顺序：
1.直接访问（通过变量名）
2.顺序访问（索引、切片）：字符串、列表、元组
3.映射访问：字典
存放元素个数：
1.容器类型（多个）：类表、元组、字典
2.原子（一个）：数字、字符串
