python 基础知识点一

基础数据类型初始。

数字：int 12,3,45 + - * / **    int： bit_lenth()转化为2进制的最小位数。
% 取余数
ps:type()
字符串转化成数字：int(str) 条件：str必须是数字组成的。
数字转化成字符串：str(int)
字符串：str，python当中凡是用引号引起来的都是字符串。
可相加:字符串的拼接。
可相乘：str * int
bool:布尔值。 True False。bool(int)可以转换为 T or F 。0为T；非0为F

str---->bool :bool(str)； s = " " （空字符）---> False;  s = "1"（非空字符）---> True

ig = 0;st ='';l = {};s=[];se=set()

#bool值都为0

s = input("")

if s:

　　pass

else:

　　pass

字符串的切片（顾头不顾尾）

[首：尾：步长]  步长为1（正向取）一般省略；步长为-1（反向取）；步长为2（隔一个取） 

s="ABCDKSDFESF"

s1=s[:]   s1=s[0:]   ----> s1="ABCDKSDFESF"  

s2 =s[::-1] s2=s[-1::-1]  -----> s2="FSEFDSKDCBA"

字符串常用方法

s ="asDSswWss"
s1 = s.upper()  upper() 全部大写
s2 = s.lower()   lower()  全部小写
print(s1,s2)    

#captalize,swapcase,title
print(name.capitalize()) #首字母大写
print(name.swapcase()) #大小写翻转
msg='taibai say hi'
print(msg.title()) #每个单词的首字母大写

# 内同居中，总长度，空白处填充*
ret2 = a1.center(20,"*")  
print(ret2)

#数字符串中的元素出现的个数。
# ret3 = a1.count("a",0,4) # 可切片
# print(ret3)


a4 = "dkfjdkfasf54"
#startswith 判断是否以...开头
#endswith 判断是否以...结尾
# ret4 = a4.endswith('jdk',3,6)  # 顾头不顾尾
# print(ret4)  # 返回的是布尔值
# ret5 = a4.startswith("kfj",1,4)
# print(ret5)

#寻找字符串中的元素是否存在
# ret6 = a4.find("fjdk",1,6)
# print(ret6)  # 返回的找到的元素的索引，如果找不到返回-1

# ret61 = a4.index("fjdk",4,6)
# print(ret61) # 返回的找到的元素的索引，找不到会报错。

#不写默认按照空格分割
#split 以什么分割，最终形成一个列表此列表不含有这个分割的元素。split可以把str 转换为 list.
# ret9 = 'title,Tilte,atre,'.split(','，次数)#不写次数，默认全部.
# print(ret9)
# ret91 = 'title,Tilte,atre,'.rsplit('t',1) rsplit(从右开始分割） 
# print(ret91)

#join 可以把list(里面要为str) 转换为 str
s=["alse","2","6","9"]
s1 = '+'.join(s)
print(s1)
alse+2+6+9

#format的三种玩法 格式化输出
res='{} {} {}'.format('egon',18,'male')
res='{1} {0} {1}'.format('egon',18,'male')
res='{name} {age} {sex}'.format(sex='male',name='egon',age=18)

#strip strip() 括号里面有什么就可以删什么，默认删除空格和
（换行符）
#该方法只能删除开头或是结尾的字符，不能删除中间部分的字符
name=' *barry** .'
print(name.strip('*')) print(name.strip('* .'))  
print(name.lstrip('*')) rstrip(从右开始删除)
print(name.rstrip('*'))  lstrip(从左开始删除)

#replace(old,new，次数)
name='alex say :i have one tesla,my name is alex'
print(name.replace('alex','SB',1))

#####is系列
name='taibai123'
print(name.isalnum()) #字符串由字母或数字组成
print(name.isalpha()) #字符串只由字母组成
print(name.isdigit()) #字符串只由数字组成　
print(name.isspace()) #字符串只由空格组成

while。

while 条件:
循环体
无限循环。
终止循环：1，改变条件，使其不成立。2,break

while 1:                while True :

　　pass      比             pass           的效率高

while else

当while循环被break打断市，就不会执行else的结果。

若没有break，则结束循环后最后会执行else语句。

continue ：跳过本次循环，继续下一次的循环。

变量

变量：就是将一些运算的中间结果暂存到内存中，以便后续代码调用。
1,必须由数字，字母，下划线任意组合，且不能数字开头。
2，不能是python中的关键字。
['and', 'as', 'assert', 'break', 'class', 'continue',
'def', 'del', 'elif', 'else', 'except', 'exec',
'finally', 'for', 'from', 'global', 'if', 'import',
'in', 'is', 'lambda', 'not', 'or', 'pass', 'print',
'raise', 'return', 'try', 'while', 'with', 'yield']
3，变量具有可描述性。
4,不能是中文。
7，常量。
一直不变的量。 π
BIR_OF_CHINA = 1949

注释

方便自己方便他人理解代码。
单行注释：#
多行注释：'''被注释内容''' """被注释内容"""  ("""可以输出位置不变的多行str)

用户交互。input

1，等待输入，
2，将你输入的内容赋值给了前面变量。
3，input出来的数据类型全部是str

格式化输出

%为占位符，s,d为替换的类型 s(str);d(digit)  

用法：'%s,%d'%(name,age)

%%只是在格式化输出中显示%

dic = {'name':'zzz','age':24}
a = 'name:%s,age:%d' % (dic['name'],dic['age'])
print(a)

　　

编码

最早的密码本为ascii码 ， ascii码覆盖了英文字母大小写，以及特殊字符，数字。ascii码储存的实际上是2进制(010101010101)。用一个字节表示，一个字节为8位。

ascii码为了解决全球化的文字问题，创建了一个万国码，unicode最早一个字符是两个字节，16位表示；现在是 一个字符（中文还是英文）用四个字节（32位）表示。

Unicode 升级 utf-8 utf-16 utf-32
8位 = 1字节bytes
utf-8 一个字符最少用8位去表示，

英文用8位                              一个字节
欧洲文字用16位去表示          两个字节
中文用24 位去表示                 三个字节
utf-16 一个字符最少用16位去表示

gbk 是中国人自己发明的，一个英文用一个字节；一个中文用两个字节（16位）去表示，只能用于中文和ascii码中的文字。

1bit     8bit = 1bytes
1byte  1024byte = 1KB
1KB    1024kb = 1MB
1MB   1024MB = 1GB
1GB    1024GB = 1TB0

编码的注意事项：1，各个编码之间的二进制是不能识别的，容易产生乱码。

2，文件的传输和存储只能是bytes类型，不是unicode. bytes类型包含常用的 utf-8，gbk，ascill码等。

str 在内存中是用unicode编码。要想文件的传输和存储只能将str--------->bytes ，用encode('utf-8')编码.

对于英文来说,  str :  表现的形式为  a = 'alex' ,  编码的方式为 unicode;

　　　　　bytes  :  表现的形式为   a =b'alex' , 编码的方式为  utf-8,gbk...

对于中文来说,  str :  表现的形式为  a = '中国' ,  编码的方式为 unicode;

　　　　　bytes  :  表现的形式为   a =b'xe4xb8xadxe5x9bxbd', 编码的方式为  utf-8,gbk...

s = '中国'
s1 = s.encode('utf-8')
print(s1)  #b'xe4xb8xadxe5x9bxbd'

s = '中国'
s1 = s.encode('gbk')
print(s1)   #b'xd6xd0xb9xfa'　

 逻辑运算符

非零数为True； 0为False

优先级：（）> not>and>or,同一优先级从左往右计算。

not:返回表达式结果的“相反的值”

T and fun()  ,   执行后面fun()

F and fun()  ,   执行前面

F or fun()   ,    执行后面fun()

T or fun()  ,    执行前面

总结：or 与 and 情况相反

print(1>2 and 3 or 4 and 3 <2)
print(2 or 1<3 and 2)

False
2　　

 注意：不要在列表和字典的循环中删除列表或者是字典里面的元素，对于列表来说，不会报错但是删除的元素会有变化，但是字典会报错。

lis = [11,22,33,44,55]

for i in range(len(lis)):
    # print(i)
    if i %2 == 1:
        # del lis[i]
        lis.pop(i)
        # print(lis)
print(lis)
#该结果应当是 [11,33,55]
#但是输出的结果为[11, 33, 44] ; 因为每次删除列表中的元素，在下一次循环中，
# 该列表中的元素的index会发生改变

正确的方法：

#将列表中的index为奇数的值删去

lis = [11,22,33,44,55,66,77,88]
j=0
for i in range(len(lis)):
        if i % 2 == 1:
            if i >1:
                j=j+1
                i= i-j                  
            del lis[i]                 

print(lis)

 

#需要将该字典中的K值带K的键值对删去


dic1 ={'k1':'s','k2':'23','s':'88','w':'22'}

for i in dic1:
    if 'k' in i:
        dic1.pop(i)

print(dic1)

#RuntimeError: dictionary changed size during iteration  


dic1 ={'k1':'s','k2':'23','s':'88','w':'22'}
l =[]
for i in dic1:
    if 'k' in i:
        l.append(i)
for j in l:
    dic1.pop(j)
print(dic1)

#{'s': '88', 'w': '22'}

列表：是以[]括起来，每个元素以逗号隔开，而且他里面可以存放各种数据类型

增

li = [1,'a','b',2,3,'a']
# li.insert(0,55) #按照索引去增加
# print(li)
#
# li.append('aaa') #增加到最后
# li.append([1,2,3]) #增加到最后
# print(li)
#
# li.extend(['q,a,w']) #迭代的去增
# li.extend(['q,a,w','aaa'])
# li.extend('a')
# li.extend('abc')
# li.extend('a,b,c')
# print(li)

　删　

# l1 = li.pop(1) #按照位置去删除，有返回值
# print(l1)

# del li[1:3] #按照位置去删除，也可切片删除没有返回值。
# print(li)

# li.remove('a') #按照元素去删除
# print(li)

# li.clear() #清空列表

　改　

# 改
# li = [1,'a','b',2,3,'a']
# li[1] = 'dfasdfas'
# print(li)
# li[1:3] = ['a','b']
# print(li)

index（方法用于从列表中找出某个值第一个匹配项的索引位置）# 但是对于重复的元素来说 index 只能返回相同元素的一个元素的索引位置：

l=[11,2,3,3,7,9,11,2]
for i in l:
	# 对于Index来说 元素相同 就 返回第一个元素的索引；
	n = l.index(i)
	print("index:",n,"元素",i)
# index: 0 元素 11
# index: 1 元素 2
# index: 2 元素 3
# index: 2 元素 3
# index: 4 元素 7
# index: 5 元素 9
# index: 0 元素 11
# index: 1 元素 2

　　

count（数）（方法统计某个元素在列表中出现的次数）。

sort （方法用于在原位置对列表进行排序）。如果列表中为非数字字符串，也可以排序,是按照第一个元素的ascii码来排序的。

li = ["曾辉","sss","wwww"]
li.sort()

　　

 reverse （方法将列表中的元素反向存放）。

a = [2,1,3,4,5]
a.sort()# 他没有返回值，所以只能打印a
print(a)
a.reverse()#他也没有返回值，所以只能打印a
 print(a)

元组被称为只读列表，即数据可以被查询，但不能被修改，所以，字符串的切片操作同样适用于元组;但是元组的儿子不能改，但是孙子可能可以改变。如果元组里面只有一个元素，并且不加‘，’（逗号），则该元素是什么类型就是什么类型的

tup1 = ([1])
tup2 = ([1],)
print(tup1,type(tup1))  #[1] <class 'list'>
print(tup2,type(tup2))   #([1],) <class 'tuple'>

tu=(1,3,6,["asa",2,6],"sss")
tu[3][0] = "ss"
print(tu)

(1, 3, 6, ['ss', 2, 6], 'sss')　

range  实际是按照数字顺序排列的列表，也可切片，有步长。

for i in range(0,10,1):
    print(i)
for i in range(0,10,-1):
    print(i)
for i in range(10,0,-1):
    print(i)
for i in range(10,-1):
    print(i)

0,1,2,3,4,5,6,7,8,9

什么都不输出也不报错

10,9,8,7,6,5,4,3,2,1

什么都不输出也不报错

　dict （字典是python中唯一的映射类型，采用键值对（key-value）的形式存储数据。）

数据类型划分：可变数据类型，不可变数据类型
不可变数据类型：元组，bool int str 可哈希
可变数据类型：list，dict set 不可哈希
dict key 必须是不可变数据类型，可哈希，
value：任意数据类型。
dict 优点：二分查找去查询
存储大量的关系型数据
特点：无序的

增

dic1 = {'age': 18, 'name': 'jin', 'sex': 'male'}

dic1['age'] = 12 #若存在相同的K值，则会改变value（覆盖）
dic1['height'] = 175 #若没有K值，则会直接添加
print(dic1)

dic1.setdefault('age') #若存在相同的K值，则value不会覆盖
dic1.setdefault('height',175) #若没有K值，则会直接添加
print(dic1)

删　　

dic1 = {'age': 18, 'name': 'jin', 'sex': 'male'}

dic1.pop("age"),有返回值，返回的是value
print(dic1.pop('二哥',None))  #若删除找不到的K值，必须添加返回值，不然会报错
print(dic1.popitem()) #返回值为一个元组（K,V）
del dic1['age']
del dic1['二哥']  #若删除找不到的K值,会报错
del dic1
dic1.clear()

print(dic1)

改

dic1 = {'age': 18, 'name': 'jin', 'sex': 'male'}
dic1['age'] = 16
#update  相同K的value值覆盖，没有的K-v 添加
dic = {"name":"jin","age":18,"sex":"male"}
dic2 = {"name":"alex","weight":75}    
dic2.update(dic) 
print(dic2)

查

dic = {"name":"jin","age":18,"sex":"male"}

for i in dic.values():
    print(i)
for i in dic: #for i in dic.kes()
    print(i)
for i in dic.items(): #返回的是一个元组（K,V)
    print(i)
for i,j in dic.items():
    print(i,j)

dic = {"name":"jin","age":18,"sex":"male"}

v1 = dic['weight']  #报错
print(v1)
print(dic.get('weight'，0))  #用get 找不到k不会报错，则会返回0

enumerate：枚举，对于一个可迭代的（iterable）/可遍历的对象（如列表、字符串）
enumerate将其组成一个索引序列，利用它可以同时获得索引和值。（索引，值）

li = ['alex','银角']
for i in enumerate(li):   #索引的起始位置默认是0
    print(i) #    (0, 'alex')，(1, '银角')
for index,name in enumerate(li,1):  #索引的起始位置变为1
    print(index,name) #1 alex；2 银角
for index, name in enumerate(li, 100):  # 起始位置默认是0，可更改
    print(index, name) #100 alex；101 银角

dic = {'name':'alex','age':25,'sex':'nan'}

for i in enumerate(dic):  #字典默认循环遍历K
    print(i)  #(0, 'name');(1, 'age');(2, 'sex')

for j in enumerate(dic.items()):
    print(j)  # (0, ('name', 'alex'))　

集合（set）

集合本身是可变类型（不可哈希），不能作为字典的键（K）。但是它里面的元素是可哈希的（不可变类型）

集合是无序的，不重复的数据集合。集合最重要的两点：

　　1.去重，把一个列表变成集合，就自动去重了。

　　2.关系测试，测试两组数据之前的交集、差集、并集等关系。

1.集合的创建

st1 = set({1,2,3,'abc'})
print(st1,type(st1))

st2 = {1,2,3,'abc'}
print(st2,type(st2))

2集合的增

st2 = {1,2,3,'abc'}

st2.add('qaz')

st2.update('abc')
st2.update('老师')  #update 为可迭代增加
print(st2)

3.集合的删

st2 = {1,2,3,'abc'}

print(st2.pop())   #随机删除 ; 并且有返回值
# st2.remove('abc')  #若找不到删除元素的，会报错
print(st2)

st2 = {1,2,3,'abc'}

# del st2     #删除集合  
st2.clear()   #清空集合；空的集合的变现形式为set()
print(st2)

4.集合的查

st2 = {1,2,3,'abc'}

for i in st2:
    print(i)

5，集合的其他操作：

　　1交集。（&  或者 intersection）　　　

st2 = {1,2,3,4,5,6}
st1 = {5,6,7,8,9,10}
# print(st2 & st1)
# print(st2.intersection(st1))　

　　2并集。（| 或者 union）

st2 = {1,2,3,4,5,6}
st1 = {5,6,7,8,9,10}

# print(st1 | st2 )
# print(st2.union(st1))

　　3差集。（- 或者 difference）

st2 = {1,2,3,4,5,6}
st1 = {5,6,7,8,9,10}

# print(st1 - st2)  #被减数(前)相对于减数(后)的特有的部分
# print(st2.difference(st1))

　　4反交集。 （^ 或者 symmetric_difference）

st2 = {1,2,3,4,5,6}
st1 = {5,6,7,8,9,10}

print(st2 ^ st1)

　　5子集与超集

st2 = {1,2,3,4,5,6}
st1 = {5,6}

print( st1 < st2)  #返回的是pool值
print(st1.issubset(st2))  #st1是st2的子集

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

6.frozenset不可变集合，让集合变成不可变类型。　#只读

s = frozenset('barry')
print(s,type(s))
 #返回值为：frozenset({'y', 'a', 'b', 'r'}) <class 'frozenset'>