python基础

一.while循环

1.数字非0的bool值

#while判断条件非0
while 1:
    print("你好")   #无限打印“你好”

#while判断条件为0
while 0:           #0的bool值为False
    print("哈哈")   
    
    

2.while else

#人为打破的while循环，else不执行，自己执行完不满足条件了，else执行
i=1
while i<5:
    print(i)
    i+=1
else: 
    print("over")
#1,2,3,4,over

i=1
while i<5:
    print(i)
    i+=1
    if i==3:
        break      #人为打破while循环
else: 
    print("over")
#1，2

二. 字符串格式化

1.方法一：%

#一个%代表占位
s="天气好%s%"%("好")
print(s)    #ValueError: incomplete format。错误原因：%后没跟数据类型

#两个%代表转义
s="天气好%s%%"%("15")
print(s)    #天气好15%

2.方法二：f

#f只有在python3.6之上才能使用
what="下雨"
a=f"今天{what}"
print(a)         #今天下雨

3.方法三：format

a="我是{}{}".format("好","人")
print(a)         #我是好人

name = "alex{2},{0},{1}"      
print(name.format("a","b","c"))   #按照索引值进行填充（"a","b","c"相当于元组）。
#打印结果为:"alexc,a,b"

name = "alex{a},{b},{c}"
print(name.format(a=1,c=2,b=3))  #按照关键字进行填充
#打印结果为："alex1,3,2"

三. 编码

'''
ascii   (美国)    	不支持中文
gbk     (国标)    	英文1字节   中文2字节
unicode (万国码)  		英文2字节   中文4字节 (中文任何字符，包含标点符号)
utf-8   (可变长编码)   英文1字节   欧洲2字节  亚洲3字节
'''

'''  系统默认编码
linux   --utf-8
mac     --utf-8
windows --gbk
'''

''' 单位换算
1字节=8位
1Bytes=8bit
1024Bytes=1KB
1024KB=1MB
1024MB=1GB
1024GB=1TB
'''

四.运算符

1.算数运算符

# + - * / ...
python2:
    -- 5/2=2
    -- 5.0/2=2.5
    -- ps:/除数和被除数都为整数，结果为得到商的整数部分；在除数或被除数加上小数点，得到正确值
python3:
    -- 5/2=2.5
    -- 5//2=2
    -- ps:/得到准确值，//得到商的整数部分

2.比较运算符

> < == !=

3.赋值运算符

= -= += *=  ...

4.逻辑运算符

and 两边都为真取后面值 两边都为假取前面的
or  两边都为真取前面值，两边都为假取后面值
not
优先级: ()>not>and>or
#例子：1 and 2 or 3 not False and 4 or (1 and 2)

5.成员运算符

in
not in

五.整型和布尔值的转换

1.进制之间的转换

二进制转换成十进制：v = “0b1111011”
print(int('0b1111011',2))
十进制转换成二进制：v = 18
print(bin(18))
八进制转换成十进制：v = “011”
print(int('011',8))
十进制转换成八进制：v = 30
print(oct(30))
十六进制转换成十进制：v = “0x12”
print(int('0x12',16))
十进制转换成十六进制：v = 87
print(hex(87))

2.布尔值

bool() 布尔值
print(bool(1))  # 数字非零的就是True 零就是False
print(bool("")) # 字符串不为空就是True ,字符串中没有任何内容就是False

bool: False
数字: 0
字符串: ""
列表:[]
元组:()
字典:{}
集合: set()
其他: None

六.字符串详解

1.字符串方法
(1).s.upper() 大小写应用场景：验证码

1.s.upper()           #全部大写
s="Abc5" 
print(s.upper())      #ABC5
2.s.lower()       	  #全部小写
s="AbC"
print(s.lower())  	  #abc

(2)s.startswith() 以什么开头、以什么结束

1.s.startswith()      #以什么开头
s="nihao"
print(s.startswith("n"))  #True，返回bool值
s="nihao"
print(s.startswith("i",1)) #取下标为1及之后的字符串，看是否以i开始
2.s.endwith()  #以什么结束
s="nihao"
print(s.endswith("h",2)) #取下标为2及之后的字符串，看是否以h结束

(3).s.count() # x、start_index、end_index

s="xxssooeesfc"
print(s.count("s"))  #查看s的字符个数

print(s.count("s",1,4))  #查看下标(1,4)之间字符s的个数

(4).s.strip() #去除头尾两端的空格和换行符以及制表符 \n \t

s="  你好  "
print(s.strip()) #s="你好"

(5).s.split() #分割

s="alexlaaa"
print(s.split("l"),maxsplit=1) #['a','exlaaa'] maxsplit为切割次数

(6).s.replace() #代替

s1 = s.replace("肉夹馍","大煎饼")
s1 = s.replace("肉夹馍","大煎饼",1) # 指定替换的次数
print(s1)

(7).s.join() #字符串拼接

str = "-"
seq = ("a", "b", "c") # 字符串序列
print(str.join( seq ))  #a-b-c  将str作为分隔符和seq组成新的字符串,序列中的每个元素也必须是可迭代

(8).其他操作

1.capitalize()    #首字母大写
name = "alex"
name1=name.capitalize()   #字符串为不可变数据类型，值不变时内存地址不变（所以要新的地址）
print(name1)      #Alex

2.title()    #每个单词首字母大写
name = "alex hello"          #alex#hello  特殊符号隔开也可以
name1 = name.title()
print(name1)      #Alex Hello  

3.swapcase() #大小写反转
name = "Alex"
print(name.swapcase())  #aLEX

4.center()   #居中 -- 填充
name = "alex"
print(name.center(10,"-"))  #---alex---  得到总长度为10，将原字符居中，将-填充至两边

5.find()、index()     #查找 从左向右 只查找一个
name = "alelx"
print(name.find("b"))  #find查找不存在的返回-1
print(name.index("b"))   #index查找不存在的就报错

# is系列
s = "12.3"
print(s.isalnum()) # 判断是不是字母,数字,中文
print(s.isalpha())  # 判断是不是字母,中文
print(s.isdigit())  # 判断字符串是不是全都是阿拉伯数字
print(s.isdecimal())  # 判断是否是十进制

2.字符串切片、步长
参考：https://www.jianshu.com/p/15715d6f4dad

# 一个完整的切片包含两个(:)，用于分割start_index、end_index、step三个参数，默认step为1
# 两个完整的索引值如果是从左往右，步长也必须是正数，如果是从右往左，索引值必须是负数，总而言之，索引的方向要和步长的方向一致。如果索引不完整，要根据步长来决定。
# 切片中的索引值包头不包尾

a = "123456789"

(1).切取完整的值

a[:]     #从左往右   ==a[0:最后:1]
a[::]    #同上      
a[::-1]  #从右往左   ==a[-1:最前:-1]

(2).start_index和end_index全部为正（+）的情况

a[1:6]   #12345
a[1:6:-1]  #空值 索引方向和步长不一致，得出结果为空
a[6:1] #空值 索引方向和步长不一致，得出结果为空

(3).start_index和end_index全部为负（-）的情况

a[-1:-2:]  #空值 索引方向和步长不一致，得出结果为空
a[-5:-1]   #56789
a[-1:-2:-1] #9

(4).start_index和end_index不同符号

a[-1:2]  #空值 索引是从右往左，step默认为1，是从左往右
a[-8:5]  #2345 索引和步长方向一致
a[-1:2:-1] #987654 
a[-8:5:-1] #空值 索引方向和步长不一致

七.列表

#列表---list
#	有序、可变的
#定义方式：list("123")

1.增

(1).append 追加

lst=[1,"alex",True]
lst.append("ok")     #lst=[1,"alex",True,"ok"] 在列表末尾追加一个字符

(2).insert 插入

lst=[1,"alex",True]
lst.insert(1,"ok")   #lst=[1,"ok","alex",True] 在指定下标添加

(3).extend 迭代添加

lst=[1,"alex",True]
lst.extend("ok")   #lst=[1,"ok","alex",True,"o","k"] 将可迭代对象和原列表合并

2.删

(1). del

del lst  #删除整个列表

(2).pop

# pop
#   1.默认删除最后一个
#   2.有返回值返回的是被删除的元素
#   3.通过索引进行删除

(3).clear、remove

# clear 清空列表
# remove 通过元素进行删除

3.改

# lst[0] = 1
# lst[1:2] ="qaaa"   # 元素可以超出切片的位数
# lst[1:4:2] = "12"  # 元素和位置一一对应,多也不行少也不行

4.其他操作

1.sort()   #排序(默认升序)   sort(reverse=True)降序
lst = [1,2,5,432,77,3,6]
lst.sort()
print(lst) #[1, 2, 3, 5, 6, 77, 432]

2.reverse() #反转
lst.reverse()
print(lst)  #[6, 3, 77, 432, 5, 2, 1]

3. *
lst = [[]]
new_lst = lst * 5 
print(new_lst) # # [[], [], [], [], []]

4. +
lst = [1,2,3]
lst1 = [4,5,6]
print(lst + lst1)


5.枚举
lst = [1,2,3]
for i in enumerate(lst,19):    #参数二不写默认从0开始
    print(i)
#打印结果 (19,1) (20,2),(30,3)

八.元组

元组就是不能被修改的列表（不能增删改、只能查看）

#创建
1.创建空元组  a=()
2.元组中只有1个值时，必须加逗号  a=(1,)
3.可以不带括号 a=1,2   a=1,

+、*操作

1.+
a = (1,2,4)
b = (3,5,7)
print(a+b)   #(1, 2, 4, 3, 5, 7)

2.*
a = (1,2,4)
b = a * 2
print(b)     #(1, 2, 4, 1, 2, 4)

查询

tup = (1,3,4,4,4,5,6,7)
tup.index(3)   #查询元组中3的第一个下标
tup.count(4)   #查询元组中4的个数

九.range()

语法
range(start, stop[, step])
参数
start--->>从某数开始计数，默认0
stop--->>从某数结束，顾头不顾尾
step--->>步长

十.字典

字典是无序、可变的数据类型。内存中存的是键对应的值的地址

字典的键：

1.不可变的数据类型（可哈希的），例：list可变，不可作为键;

2.要求唯一。如果有重复的后面的值将覆盖前面的。

字典创建

# {} 空字典
dict(a='a', b='b', t='t')
dict(zip(['one', 'two', 'three'], [1, 2, 3]))   # 映射函数方式来构造字典
dict([('one', 1), ('two', 2), ('three', 3)])  # 可迭代对象方式来构造字典

1.dict.fromkeys(seq[, value]) #fromkeys函数用于创建一个新字典，seq序列为键，value为对应的初始值。

seq=["1","2","3"]
dic=dict.fromkeys(seq)
#结果为:dic={"1":None,"2":None,"3":None}

dic=dict.fromkeys(seq,10)
#结果为:dic={"1":10,"2":10,"3":10}


dic["1"] = 2
#结果为:dic={"1":2,"2":2,"3":2}     #fromkeys给每个键都赋相同的值，地址也相同，所以当其中一个键的值改变时，其他值也改变。

1.增

# dic={"a":"a","b":"b"}

1.暴力添加
dic["a"]="A"  #{"a":"A","b":"b"}

2.setdefault(key,value) #键如果存在，返回原来值；键不存在，添加进入
dic.setdefault("a",100)
print(dic)  #{"a":"a","b":"b"}
# dic.setdefault("c","c")
# print(dic) #{"a":"A","b":"b","c":"c"}

2.删

1.del dic["a"]    #通过字典的键删除

2.dic.pop("a")    #通过字典的键删除，返回删除的值

3.dic.clear()     #清空

4.dic.popitem()   #默认删除最后一个，返回删除的键值对

3.改

1.dic["a"]="a"   #通过键进行更改

2.dic.update()   #如果键存在，则覆盖；不存在，则创建
dic={"a":"a","b":"b"}
dic2={"c":"c","a":"5"}
dic.update(dic2)
print(dic)      #{'a': '5', 'b': 'b', 'c': 'c'}

4.查

1.dic.get()    #如果键存在，返回其值；如果不存在，返回None
print(dic.get("a"))  #a
print(dic.get("A"))  #None

5.其他操作

1.
for i in dic:             #i为字典的键
    print(i,dic.get(i))   
'''
结果：
a a
b b
'''

2.keys()    #遍历字典的键（高仿列表）
for i in dic.keys():
    print(i)

3.values()  #遍历字典的值（高仿列表）
for i in dic.values():
    print(i)
    
4.items()   #遍历字典的键和值
for key,value in dic.items():
    print(key,value)

    
# print(dic.keys())         dict_keys(['a', 'b', 'c'])
# print(dic.values())       dict_values(['5', 'b', 'c'])
# print(list(dic.keys))     将字典的键转化为列表
# print(list(dic.values())) 将字典的值转化为列表

十一.集合

1.概念

集合-----set
***可变、无序、不支持索引、天然去重***
# set() 空集合

2.定义

s = {1,1,2,3,3,4,6,6}
print(s)   #{1,2,3,4,6}

3.增

s.add("76")          #只能添加一个
# print(s)   #{1,2,3,4,6,"76"}
s.update("你好")      #迭代添加 
# print(s)   #{1,2,3,4,6,"你","好"}

4.删

print(s.pop())   #随机删除，因为pop函数默认删除最后一个，打印集合时又是无序的，所以是随机删除
s.remove(3)     # 指定元素删除
s.clear()         # 清空   -- set() 空集合

5.其他操作

# s1 = {1,2,3,4,5,6,7}
# s2 = {5,6,7,1}
# print(s1 & s2)  # 交集
# print(s1 | s2)  # 并集
# print(s1 - s2)  # 差集
# print(s1 ^ s2)  # 反交集
# print(s1 > s2)  # 父集(超集)
# print(s1 < s2)  # 子集

# print(frozenset(s1))  # 冻结集合 更不常用
# dic = {frozenset(s1):1}
# print(dic)

十二.文件操作

1.打开文件方式：

w     #只写不读，打开文件会清空文件内容重新写（字符）
r     #只读不写（字符)
wb    #只写不读（字节），不涉及encoding
rb    #只读不写（字节），不涉及encoding
w+    #先写后读（写完之后光标在最后）
r+    #先读后写
a     #追加（只写）
a+    #追加（可读）

# mode="w" 只写
f=open("t1","w",encoding="utf-8") 
f.write("nihao")           

# mode="w+" 写读(不常用)
f=open("t1",mode="w+",encoding="utf-8")
f.write("你好啊")   
print(f.read())   #此时读取不到数据，因为write完成之后，光标在最后

# mode="r" 只读
f=open("t1",mode="r",encoding="utf-8")
print(f.read())

# mode="r+" 读写
f=open("t1",mode="r+",encoding="utf-8")  #打开文件，光标在0
print(f.read())
f.write("哈哈")   #不清空原有内容，追加写

# mode="a"  追加
f=open("t1",mode="a",encoding="utf-8")  #在已有的末尾添加
f.write("哈哈")

# mode="a+"
f=open("t1",mode="a+",encoding="utf-8")  #打开文件时光标在最后
print(f.read())    
f.write("哈哈")

# mode="rb"
f=open("t1.jpg",mode="rb")     
print(f.read())           
f.write("哈哈")

# mode="wb"
f=open("t1.jpg",mode="wb")  
f.write()  
f.write("哈哈")

2.其他操作

f.flush()   #把缓冲区的内容刷新进磁盘
f.tell()    #光标的位置（按照字节数）
f.seek()    #移动光标位置 
	--0,0   #移动到开头
    --0,1   #移动到当前
    --0,2   #移动到末尾
    --3     #如果是中文就移动一位，英文移动3位

#不用自己关闭文件,自动调用close方法
with open("t11",mode="r",encoding="utf-8") as f1,\
open("t12",mode="w",encoding="utf-8") as f2:
    print(f1.read())
    f2.write("xx")

文件路径中如果要转义，两种方式：
1."\\test1\\das.txt"       #\\
2.r"\test1\das.txt"        #repr  
	a = '[1,3,3]'
	print(repr(a))         #'[1,3,3]'

3.read注意

1.文件句柄f相当于一个迭代器，f.readlines()是将每一行的结果组成一个列表
2.for循环遍历文件句柄f和f.readlines()得到的结果相同
3.f.read()读取的是字符串，for循环遍历打印的是每个字符
4.f.read(4) #读取4个字符(4个中文汉字或4个英文字母)
5.f.read()和f.readlines()都是将文件全部读取，f.readline()是一行一行读取。

4.路径

#返回上一级 ..\