python基础篇

1.变量

变量定义包含：变量名、值、数据类型、地址

变量名的规范起名（数字字母下划线，数字不能开头）、规范化（大小驼峰、下划线）

数值类型：int,float,bool,complex 判断类型的函数：type(5.9)

数据结构类型：数字、集合(set)、字符串(str)、元组(tuple)、列表(list)、字典(dict)

1.定义变量，多行注释
a='''int
hello
world'''
print(a)
输出结果：
int 
hello
world

2.字符串输出引号，使用转义字符（输出其他字符也是）
a="hello \"w\" world"
print(a)
输出结果：
hello "w" world

3.字符串运算符
字符串拼接：
a="hello"
b="world"
print(a+" "+b)
输出结果：hello world

字符串重复
a="hello"
print(a*2)
输出结果：hellohello

in,not in判断是否在字符串内
a="hello"
print("h" in a)
print("h" not in a)

r或R原字符输出
a="hello\nworld"
输出结果：
hello 
world
print(r"\n")
输出结果：\n

4.格式化输出
%c字符  %s字符串   %d有符号十进制整数   %u无符号十进制整数  %o八进制整数 %0x十六进制整数   %f浮点数   %e科学计数法   %g（%f,%e的简写）
格式化输出思路：定义模板%变量
(1)第一种方法
%s字符串形式输出
age=19
name="tom"
print('名字是%s,年龄是%d'%(name,age))
输出：名字是tom，年龄是19

%f浮点数
a=1.23456
print('%f'%a)  #默认保留6位小数
print('%.2f'%a)  #保留2位小数

%d十进制
a=1.35
print('%d'%a)
结果输出：1

%o八进制
a=11
print('%o'%a)
输出结果：13

(2)format()输出
①不带编号
print('{},{}'.format(10,11))
结果输出：10,11
a='hello'
b='world'
print('{} {}'.format(a,b))
print('{} {}'.format(b,a))
结果输出：
hello world
world hello

②带数字编号，可调换顺序，即{1}{2}
print('{0} {1}'.format('hello','world'))
print('{0} {1} {1}'.format('hello','world'))
print('用户名：{name},地址：{url}'.format(name='sszdlbw',url='www.sszdlbw.com'))
结果输出：
hello world 
hello world world
用户名：sszdlbw，地址：www.sszdlbw.com

(3)f'{}'输出 不需要考虑数据（f'{}'中的字符串表达式不建议用单引号，会报错）
name='sszdlbw'
age=19
print(f'名字：{"name"}，年龄：{age}')
结果输出：名字：sszdlbw，年龄：19

2.运算符

转义字符：\t（制表符，一个\t相当于4个空格）, \'（'的输出）,\"（"的输出）

name='sszdlbw'
age=20
print('名字\t\t\t年龄')
print(f"{name}\t\t{age})
结果输出：
名字            年龄
sszdlbw        20

print()相当于print("",end="\n")，自动换行，如果以其他方式结束，则写print("",end="*")或其他。

算术运算符：+,-,*,/,//（取整除）,%（取余）,**（幂）

赋值：=,+=,-=,*=,/=,//=,%=,**=

类型转换：

函数	说明
int(x)	将x转为整数
float(x)	转为浮点数
complex(real)	创建复数，real为实部，imag为虚部
str(x)	转为字符串
repr(x)	转为表达式字符串
eval(str)	计算在字符串中的有效python表达式，并返回一个对象
tuple(s)	序列s转换为元组
list(s)	序列s转换为列表
chr(x)	整数转换为Unicode字符
ord(x)	字符转换为它的ASCII整数值
hex(x)	整数转换为十六进制字符串
oct(x)	整数转换为八进制字符串
bin(x)	整数转换为二进制字符串

输入：input（接收到的任意用户输入的数据都当作字符串处理）
input('输入年龄')
name=input('输入名字')
print(name)
print(type(name))
输入年龄：19
输入名字：sszdlbw
sszdlbw
<class 'str'>

a=int(input('输入整数：'))   #限制用户输入是整数
print(a)
b=float(input('输入浮点数：'))  #限制输入是浮点数
print(b)
c=eval(input('输入数字：'))   #限制输入数据为数字
print(c)

3.比较

1.if语句：缩进决定是否在选择的执行语句中。
age=20
name='sszdlbw'
score=90
if age>20:
    print('ok')
else:
    print('no')
    
2.多层选择：（所有条件都不能满足时用else，一般放最后）
if score<60:
    print('60以下')
elif score>=60 and score<80:
    print('60~80')
elif score>=80:
    print('80以上')
else:
    print('成绩异常')
3.if嵌套
if age>20:
    if name=='sszdlbw':
        print('结果1')
    else:
        print('结果2')
else:
    print('结果3')

逻辑运算符：
and（与）,or（或）,not（非）
a=10 
b=2
c=False
print(a and b)  #a为10，还要看b
print(c and b)  #c为false， 结果直接false
print(a or c)  #a为10，结果直接为10，不用看后面
print(c or a)  #c为false，还要看a
print(not 0)   #结果为1
print(not 1)   #结果为0

三元表达式：
a=1
b=2
print(a if a>b else b)
print('a最大') if a>b else print('b最大')
输出结果：
2
b最大
（插入知识点：生成随机数使用random，
import random
num=random.randint(0,2)  #表示随机生成0，1，2三个整数中的一个
random.choice('孙悟空','沙和尚','白龙马')
）

4.判断

#循环的三个关键点：初始状态，结束条件，循环体（避免进入死循环）
#while循环
i=0
while i<100:
    i+=1
    break  #跳出离的最近的循环
else:
    print('循环结束')
    
#for循环
for j in range(0,5):    #相当于[0,5)  也可以写为for j in range(5)
    print('第'+j+'次循环')
    if j>2:
        continue
    else:
        print('前三次输出')
    print('continue会直接跳过本条语句，直接进行下一次的循环')

5.字符串列表

字符编码：Unicode(兼容万国语言)，utf-8(对不同字符用不同的长度表示)，gbk(用于专门解决中文编码，双字节的)，utf-8编码的中文使用了3个字节。

#1.encode编码：将字符转换成字节流（二进制数据流）
a='hello'
print(type(a))   #<class 'str'>
b=b'hello'  
print(b)  #b'hello'
print(type(b))   #<class 'bytes'> 字节码（字节流）

#将字符串转换成二进制数据流
a='sszdlbw'
a=a.encode()
print(a)  #b'sszdlbw'
#解码：将字节流解析为字符串
a=a.decode()

#2.索引：下标，从0开始，范围是[，)
#索引支持顺序，也支持倒序
name='hello world'
print(name[0])   #h
print(name[100])   #超出范围会报错
print(name[-1])  #d
print(name[-2])  #l

#3.切片
#格式：a[起始:结束:步长]  范围是[,)；默认步长为1；步长为负，从右到左显示；切牌超出范围不会报错，查找范围截至到最后一位。
a='hello_world_sszdblw'
print(a[6:11:1])   #world
print(a[6:11:2])   #wrd
print(a[:])    #hello_world_sszdlbw  取所有
print(a[-1:11:-1])    #wlbdzss

#4.字符串的查询
#①find   格式  str_name.find('寻找的字符串str',开始,结束)
#检查寻找的字符串是否在str_name中，如果在，返回第一次找到的索引值，否则返回-1
a='hello world'
print(a.find('h'))       #0
print(a.find('e',1,3))   #1

#②index查找索引   格式：str_name.index('str',start,end)，找不到会报错
a='hello world'
print(a.index('o',0,7))  #4

#③count统计字串在字符串出现的次数   格式：str_name.count('str',start,end)
a='hello world'
print(a.count('o'))  #2

#5.字符串的修改
#①replace替换   str_name.replace('old_Str','new_str',替换次数)
a='hello world'
print(a.replace('o','b'))   #hellb wbrld
print(a.replace('o','b',1))   #hellb world

#②split分割    str_name.split('str',切的次数)
a='he/llo,wor/ld'
print(a.split(','))  #['he/llo','wor/ld']
print(a.split('/'))  #['he','llo,wor','ld']

#③capitalize  首字母变大写
a='hello world'
print(a.capitalize)   #Hello world

#④lower所有大写变小写
a='HHHHHhhhhh'
print(a.lower()) #hhhhhhhhhh

#⑤upper所有小写变大写
a='HHHHHhhhhh'
print(a.upper()) #HHHHHHHHHH

#⑥title每个单词首字母变大写
a='hello world'
print(a.title())  #Hello World

#6.字符串判断
#从判断统计可以计算大写、小写、数字、其他字符的个数
#①islower()判断是否都是小写
a='Hello world'
print(a.islower())   #False

#②isupper()判断是否都是大写
a='Hello world'
print(a.isupper())   #False

#③isdigit()判断是否是数字
a='sszdlbw111'
b=a[-1]
print(b.isdigit())

#④startswith()判断字符串是否以某字串开头
a='hello'
print(a.startswith('h'))

#⑤endswith()判断字符串是否以某字串结尾
a='hello'
print(a.endswith('o'))

#7.字符串增
#①+
#②join
a='hello'
print('*'.join(a))  #h*e*l*l*o

#8.删
#①lstrip()  删除左边空白
a='   hello'
print(a.lstrip())

#②rstrip()  删除右边空白
a='hello   '
print(a.rstrip())

#9.列表(有序，元素可以不同类型)
li=['a','b','1']
print(li[0])  #a
#循环读取列表
for i in li:   #li可迭代对象
    print(li)
#或者
j=0
while j<len(li):
    print(li[j])
    j+=1

#1.增
#①c=a+b
#②insert()方法
#格式：listname.insert(位置,插入的字符串元素)
sszdlbw=["java","python","c"]
sszdlbw.insert(1,"c++")
print(sszdlbw)  #['java','c++','python','c']
t=('c#','go')
print(sszdlbw.insert(2,t))  #['java','c++',('c#','go'),'python','c']
#③append()末尾追加元素，对元组也可
#格式：listname.append('增加的字符串')
sszdlbw=['hahaha']
print(sszdlbw.append('hbhbhb'))   #['hahaha','hbhbhb']
#④extend()
#语法：listname.extend()在列表末尾添加字符串，并把字符串拆分成单个
sszdlbw=['hahaha']
t=('a','b','c')
print(sszdlbw.extend(t))  #['hahaha','a','b','c']

#2.修改元素
#①修改一个
a=[1,2,3,4,5]
a[3]=1
print(a)  #[1,2,3,1,5]
#②修改一组
b=[1,2,3,4,5]
b[2:4]=[6,7]
print(b)   #[1,2,6,7,5] 
#特殊：对空切片赋值，对应下标前插入所有元素
a=[1,2,3,4,5]
print(a[3:3])  #[]
a[3:3]=[1,2,3,4]   #哪怕是一个元素，也要带[]，因为它是可迭代对象
print(a)   #[1,2,3,1,2,3,4,4,5]
a[0:5:2]=[-1,-1,-1]     #间隔修改
print(a)   #[-1,2,-1,4,-1]

#3.删除
#①del  格式：del listname
a=list('hello')
print(a)   #['h','e','l','l','o']
del a  #删除整个列表
print(a)   #a已经没有定义了
#del listname[位置]
a=[1,2,3,4,5]
del a[1]
print(a)   #[1,3,4,5]
#del删除多个值
del a[1:3]
print(a)  #[1,4,5]

#②pop()  格式：listname.pop(位置) 位置不写，默认删除最后一个元素
a=[1,2,3,4,5]
a.pop(2)
print(a)   #[1,2,4,5]
a.pop()
print(a)   #[1,2,4]

#③remove()值进行删除，无则报错：如有重复，删第一个
a=[1,2,2,3,4,6,4,5]
a.remove(4)
print(a)   #[1,2,2,3,6,4,5]

#④clear()删除列表所有元素
a=[1,2,3,4]
a.clear()
print(a)   #[]

#4.in在,not in不在
#5.count()统计次数  格式：listname.count(某字符串元素)
a=[1,2,2,2,3,4,5,5]
print(a.count(2))  #3

#6.查找某元素的位置   格式：listname.index(str,start,end)  后面两个可不写
a=['a','b','c']
print(a.index('c'))   #2

#7.reverse()把原列表顺序倒置
a=[1,2,3,2]
a.reverse()
print(a)   #[2,3,2,1]

#8.sort()排序
a=[1,4,3,2]
a.sort()  #默认从小到大排序
print(a)
a.sort(reverse=True)  #从大到小排序
#拓展
#sort只能用于list，sorted()内建函数
b=[1,4,3,2]
c=sorted(b)  #默认从小到大排序，修改列表
print(b)   #[1,4,3,2]
print(c)   #[1,2,3,4]
print(b.sort())   #错误写法，sort()排序或无返回值，返回none

#9.列表推导式：
a=[1,2,3,4,5,6,7]
print([i*3 for i in a])   #[3,6,9,12,15,18,21]

6.字典元组集合

元组不可修改，以(,,)形式存在

#定义单个数据的元组，必须加','
a=(10,)        #<class 'tuple'>
b=('sszdlbw',)  #<class 'tuple'>

#操作：索引,count,index,len
#拓展：元组可变的情况：元组中有可修改的数据结构类型
a=(1,2,['sszdlbw','hello'])
print(a[2][0])  #sszdlbw
a[2][1]='world'
print(a)    #(1,2,['sszdlbw','world'])

#字典：键值对成对出现，键和值一一映射，字典数据和顺序无关，不支持下标，按键查询
#定义空字典：
dict1={}
dict2=dict()

#1.修改(增加直接缀后，有则覆写)
dict1={'name':'sszdlbw','age':22}
dict1['name']='ammm'   #重新赋值
print(dict1)   #{'name':'ammm','age':22}
dict1['id']=100   #增加
print(dict1)   #{'name':'ammm','age':22,'id':100}
del dict1['age']   #删除
print(dict1)   #{'name':'ammm','id':100}
dict1.clear()   #清空
print(dict1)   #{}

#2.查询
dict1={'name':'sszdlbw','age':22}
print(dict1['name'])   #'sszdlbw'
print(len(dict1))   #2
print(dict1.keys())   #dict_keys(['name','age'])
print(dict1.values())  #dict_values(['sszdlbw',22])
print(dict1.items())  #查看所有(键,值)，返回列表
#循环遍历key,items:
for key in dict1.keys():
    print(key)
for item in dict1.items():
    print(item)
for key,value in dict1.items():
    print(f'{key}={value}')

#集合   特性：无序不重复，不支持下标操作
#定义空集合
a={}    #这不是定义空集合，而是定义空字典
a=set()   #定义空集合

#1.增
#①add()
s={10,20}
s.add(100)
print(s)    #{100,10,20}
s.add(20)  
print(s)    #{100,10,20}自动去重
#②update()  追加的数据必须是可迭代对象（如列表、集合、字典、元组）
s={10,20}
s.update(100)   #报错，这样写会被认为是整型，而整型不是可迭代对象
#添加列表 
s.update([100])
print(s)   #{100,10,20}
#添加元组  
s.update((1,2))    #{100,10,20,1,2}
#添加集合
s.update({4,5})    #{100,10,20,1,2,4,5}
#添加字典
s.update({'name':'sszdlbw'})   #只添加键   {100,10,20,1,2,4,5,"name"}
#两者合并去重
m={'a','b','c'}
n={'c','d','e'}
m.update(n)   #{'a','c','b','d','e'}
m.add(n)     #报错，add方法添加具体某个元素

#2.删除
#①remove()  删除指定数据，如果数据不存在则报错
a={1,2}
a.remove(1)
#②discard() 删除指定数据，但如果数据不存在也不报错
a={1,2}
a.discard(3)
#③pop()  随机删除集合中某个数据，并返回这个数据
a={1,2,3,4,5}
a.pop()

#交集&、并集|
a={1,2}
b={2,3}
print(a&b)   #{2}
print(a|b)   #{1,2,3}

#公共方法：len(),max(),min(),enumerate()
#enumerate()用于将一个可遍历的数据对象（如列表、元组或字符串）组合为一个索引序列，同时列出数据和数据下标。
for index, fruit in enumerate(fruits):
    print(f"索引{index}: 值{fruit}")

#列表推导式
list1=[i for i in range(10)]
#相当于
list1=[]
for i in range(10):
    list1.append(i)
print(list1)    #[0,1,2,3,4,5,6,7,8,9]

#元组推导式
a=(i for i in range(10))
print(a)   #返回的是对象地址
print(tuple(a))   #(0,1,2,3,4,5,6,7,8,9)

#字典推导式
dict1={i:i**2 for i in range(1,5)} 
print(dict1)   #{1:1,2:4,3:9,4:16}

#集合推导式
list1=[1,1,2]
set1={i**2 for i in list1}
print(set1)    #赋值给集合，会去重，输出{1,4}

7.类型转换、深浅复制

类型转换：

#dict()转换为字典
a=['a1','a2','a3','a4']
b=['b1','b2','b3']
d=zip(a,b)    #用zip将两个列表进行打包绑定，然后再转换成字典
print(d)      #返回的是对象地址
print(dict(d))    #{'a1':'b1','a2':'b2','a3':'b3'}

#传递引用
a=1
b=1
#输出a,b的内存地址，发现两个变量的数值相同时，共用一个存放数值的内存空间，也就是b没有重复存放1这个数据，而是引用了a的内存地址。

#拷贝：备份，在内存中开辟一个空间，存储相同的值。应用场景：给数据做备份，提高数据安全性；数据相同，地址不同
import copy 
a=[1,2,3,4,5]
a_copy=copy.copy(a)    #复制a的信息
print(a_copy)   #[1,2,3,4,5]
#查看它们的内存地址，发现不同，这就是引用和拷贝的区别

#深复制
import copy
a=[1,2,3,[4,5,6]]  #两层的数据列表
a_deepcopy=copy.deepcopy(a)
print(a_deepcopy)   #[1,2,3,[4,5,6]]
#深复制后两变量的值相同，但地址不同
#修改原数据a第一层元素的值时，复制后的数据不会发生变化，如下：
a[2]=100
print(a)    #[1,2,100,[4,5,6]]
print(a_deepcopy)    #[1,2,3,[4,5,6]]
#修改元数据a第二层元素的值时，
a[3][1]=10
print(a)          #[1,2,3,[4,10,6]]
print(a_deepcopy)     #[1,2,3,[4,5,6]]
#deepcopy()修改元数据不会对复制后的数据产生影响，因为是两块内存地址不同的变量

#浅拷贝：数据半共享，复制数据会独立存放，但是只拷贝成功到原数据的第一层，也就是拷贝后的第二层数据会随原数据改变
import copy
a=[1,2,3,[4,5,6]]
a_copy=copy.copy(a)
#拷贝后值相同，地址不同
#修改原数据a第一层的值，
a[0]=5
print(a)    #[5,2,3,[4,5,6]]
print(a_copy)    #[1,2,3,4,5,6]
#修改原数据a第二层的值，发现会随之变化
a[3][1]=100
print(a)    #[1,2,3,[4,100,6]]
print(a_copy)    #[1,2,3,[4,100,6]]
#总结：
#深拷贝：另外开辟一块空间完全复制，不随原数据的变化而变化，用于日常备份
#浅拷贝：开辟另一块空间半复制半数据共享，第二层数据的地址相同，所以备份数据会随着原数据第二层变化而变化，用于日常办公，不同设备能修改同一个表，一个表更新，另一个表也能数据更新。

#可变对象：存储空间保存的数据可以被修改，就是可变数据类型。比如：列表、字典、集合
m=[1,2]
print(m,id(m))
m+=[6]
print(m,id(m))
#值不同，但地址相同

基础篇的学习整理源于：b站python学习指南针