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*10a=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=7r=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.原子(一个):数字、字符串