当前位置：首页 > news >正文

python基础（一）

news 文章来源：https://blog.csdn.net/dingyahui123/article/details/144084308 2025/1/16 2:53:34

python语言特点

解释型语言	代码执行过程中通过解释器将代码转换为机器语言，并立即执行；编译型语言执行前需要经过编译整个代码文件为机器语言的可执行文件，然后执行能找出大部分错误
错误处理	解释型语言在运行时发现错误，编译型语言在编译时
执行速度	编译型语言比解释型语言执行更快，因为其代码是直接的机器码
平台依赖	编译语言生成平台特定可执行文件，解释型语言则更为跨平台，因为只需要对应平台的解释器
支持面向对象、过程化编程和函数式编程，应用广泛，通过模块和包机制高度复用和模块化设计； web:Django,Flask等框架数据分析：Pandas、NumPy等网络爬虫： Scrapy 人工智能：TensorFlow、Keras 自动化测试：Selenium自动化测试游戏开发：Pygame库2D 科学计算：Scipy 区块链： Hyperledger、Ethereum 嵌入式： MicroPython

标识符

标识符是允许作为变量（函数、类等）名称的有效字符串。有一部分是关键字，语言本身保留的标识符，这些是不能做它用的标识符的，否则会引起语法错误（SyntaxError 异常）；

Python 是动态类型语言，不像C++那种静态型语言定义的时候都要明确类型，python不需要预先声明变量的类型。变量的类型和值在赋值那一刻被初始化，变量赋值通过等号来执行。

Python的有效标识符由大小写字母、下划线和数字组成，数字不能作为开始字符，标识符的长度一般不限，Python标识符是严格大小写敏感的。

保留字

False	None	True	and	as	assert	async	await	break	class
continue	def	del	elif	else	except	finally	from	global	import
for	lambda	not	with	pass	while	nonlocal	yield	raise	return
if	in	is	or	try

number=12
my_var=1
_temp='hell'  #' ' 与"" 定义字符串，使用#单行注释
str_tem="world"
#1wo='sd' #表示符 error SyntaxError: invalid decimal literal
#if=1  SyntaxError: invalid syntax
def my_func():'''多行注释,注意行缩进规则'''sum_temp=number+\my_varday=['m','t',  #换行'w']print(sum_temp)  #13print(day)       #['m', 't', 'w']
my_func()

运算符

算数运算符	比较运算符
`a=12 #0b1010 b=10 #0b1100 print(a+b) #加 22 print(a-b) #减 12 print(ab) #乘 120 print(a/b) #除 1.2 print(a%b) #取模 2 print(a*b) #幂运算 10个12相乘 print(a//b) #向下取整 1`	`a=12 #0b1010 b=10 #0b1100 print(a==b) #等于 False print(a!=b) #不等于 True print(a>b) #大于 True print(a<b) #小于 False print(a>=b) #大于等于 True print(a<=b) #小于等于 False`
赋值运算	位运算
`a=12 #0b1010 b=10 #0b1100 c=a+b #简单赋值 22 c+=a #加法赋值 34 <>c=c+a c-=a #减法赋值 22 c=b #乘法赋值 220 c/=a #除法赋值 18.33333.. c%=b #取模赋值 8.333333.. b*=a #幂赋值 1000000000000 a//=b #取整除赋值 0`	`a=12 #0b1010 b=10 #0b1100 print(a\|b) #14 0b1110 print(a^b) #6 0b110 print(~a) #-13 -0b1101 print(a<<2) #48 0b110000 print(a>>1) #6 0b110`
逻辑运算符	成员运算符、身份运算符
`a=12 #0b1010 b=10 #0b1100 c=0 d=False print(a and b) # 10 a非false,返回b的计算值 print(a and c) # 0 a非false，返回c的计算值 print(a and d) # False a非false 返回d的计算值 print(c and a) # 0 c是false 不计算a print(d and a) # False a是false print(a or b) # 12 前一个非0，返回前一个 print(b or a) # 10 print(c or a) # 12 前一个是0，返回后一个 print(not a) # Fasle print(not c) # True print(not d) # True`	`lista=[1,2,3] a=10 b=a c=10 listb=[1,2,3] print(1 in lista) # True print(4 in lista) # False print(1 not in lista) # False print(4 not in lista) #True print(a is c) #True print(a == c) #True print(a is b) #True print(a == b) #True print(lista is listb) #False print(lista == listb) #True`

条件/循环/控制语句

条件语句 循环、控制语句

#条件控制语句
#1 if else
a=10
if a>=1:print("大于1")
else:print("小于1")
# if elif else
if 0<=a<=2:print("A") 
elif 0<=a<=3:print("A") 
elif 4<=a<=6:print("B") 
else:print("c") 
#瑞年判断
year = 2024
if (year % 4 == 0 and year % 100 != 0)\or year % 400 == 0:print(f"{year} 是闰年")
else:print(f"{year} 不是闰年")

#while循环 contine、break控制
i=1
while i<20:  #判定条件i+=1      #执行语句以及下面语句块if i%2>0:continue   #跳过本次循环if i>10:break      #退出循环print(i,end=" ") #2 4 6 8 10
flag = 1
while (flag>1): print('1!') #组合语句
else:     #while里的elseprint("完成!")
#for循环 contine、break控制
for le in 'abc':if le=='b':continueprint(le)  #a c
for i in range(1,10):if i==2:pass     #pass块print('什么也不做')if i>5:breakprint(i) #1 2 3 4 5

数据类型

变量存储在内存中的值，在创建变量时会在内存中开辟一个空间。基于变量的数据类型，解释器会分配指定内存，并决定什么数据可以被存储在内存中，可以执行什么样的操作。python基本数据类型一般分为：数值（Numbers）、字符串（String）、列表（List）、元组（Tuple）、字典（Dictionary）、集合（Set）

变量赋值

Python 中的变量赋值不需要类型声明，等号 = 用来给变量赋值，变量赋值以后该变量才会被创建，每个变量在内存中创建，都包括变量的标识，名称和数据这些信息。

num = -100 # 赋值有符号整型变量
weight = 100.0 # 浮点型
name = "hello" # 字符串 or name1='hell' or name2='''hell'''
bool_value = True # 布尔值
list_val = [1, 2, 3, 4, 5] # 列表
tuple_val = (1, 2, 3, 4, 5) # 元组
dict_val = {'name': 'AC', 'age': 25} # 字典
set_val = {1, 2, 3, 4, 5} # 集合
#创建一个整型对象，值为1，三个变量被分配到相同的内存空间上
a = b = c = 1 #多变量赋值
#两个整形对象和一个字符串对象
a1,b1,c1=1,2,'wold'

字符串与列表

str字符串 list

Python 不支持单字符类型，单字符在 Python 中也是作为一个字符串使用，支持切片操作

序列都可以进行的操作包括索引，切片，加，乘，检查成员。元素可以是list，列表的数据项不需要具有相同的类型。

#str基本操作
str_test='Hello'
str_test[0]     #H []下标取元素
str_test[0:]    #Hello 从0到结尾
str_test[1:4]   #ell  index从1到4，不含4
str_test[8:42]  #''空
#str_test[8]     #IndexError: 越界
str_test[-1::]  #反向遍历(末尾下标-1)，反转()
str_test1="World"
str_test+str_test #HelloWorld 拼接
str_test*2      # 'HelloHello' 重复
's' in str_test
print(r'hell\nls') #r/R 原始字符串不转义
#格式化
print("try %s %d"%('hell',20)) #格式化
"{}{}".format('hell','world')  #hellworld
"{1}{0}".format('hell','world')#worldhell
"{1}{0}{1}".format('a','b')    #bab
"{name}, 年龄{age}".format(name="A", age=2)

#创建list
list1 = ['python', 'hell', 2024]
list2 = []    #空列表
list3 = ["a", "b", "c", "d"]
list1[0]       #索引取值
list1[-1]      #2024
list1[:]       #切片遍历所有
list1[1:2]     #hell 左闭右开
list1[::-1]    #反向遍历
list2.append('baidu') #添加元素
del list1[0]   #['hell0', 2024]
len(list1)     #2 长度
max(list3)     #最大元素，元素类型需要一致
min(list3)
[1,2]+[2,3]    #组合
['h']*3        #['h','h','h] 重复
3 in [1,3]     # True 
for i in [1,2,3]: print(i)
print(list((1,2))) #元组转列表

字符串内置函数

s="hello wo"
s.encode(encoding='utf#8', errors='sict') # 返回字符串的编码版本，默认使用 UTF#8 编码
s.endswith('wo') #True 检查字符串是否以指定的后缀结尾，可以指定搜索的范围
s.expandtabs(tabsize=8) # 替换字符串中的 tab 符号(\t)，默认一个 tab 替换为 8 个空格
s.find('wo') #6  找到子串 sub 第一次出现的位置，可以指定搜索的范围
s.index('ll') #2 和 s.find 类似，但如果子串不存在会抛出异常
s.isalnum() #False 检查字符串是否只包含字母和数字
s.isalpha() #False 检查字符串是否只包含字母
s.isdecimal() #False 检查字符串是否只包含十进制数字
s.isdigit() #False 检查字符串是否只包含数字
s.islower() #True 检查字符串中所有的字母是否都是小写
s.isnumeric() #False 检查字符串中所有的字符是否都是数字
s.isspace() #False 检查字符串是否只包含空格
s.istitle() #False 检查字符串中的单词是否都是首字母大写
s.isprintable() #True 检查字符串中的字符是否都是可打印的
s.join('abc') #ahello wobhello woc 将可迭代对象中的元素连接起来，元素必须都是字符串
s.ljust(6) # 返回一个指定宽度 width 左对齐的字符串，默认使用空格填充
s.lower() # 将字符串中的所有大写字母转换为小写
s.lstrip() # 去除字符串左侧的空白或指定字符lsip([chars])
s.rstrip() # 去除字符串右侧的空白或指定字符lsip([chars])
s.strip() #首尾空格
s.replace('wo', 'world') # 返回字符串中 old 被替换为 new 的新字符串，可以指定最大替换次数
s.rfind('l') #3 和 s.find 类似，但从右边开始搜索
s.rindex('l') #3 和 s.index 类似，但从右边开始搜索
s.rjust(7) # 返回一个指定宽度 width 右对齐的字符串，默认使用空格填充
s.rpartition(' ') # 类似 s.partition，但是从右边开始搜索分隔符
s.upper() #'HELLO WO' 转大写
s.lower() #转小写
s.capitalize() #'Hello wo' 首字母大写
s.title()      #'Hello Wo' 标题化 每个单词大写

列表操作

#list列表操作
la = ['a', 'b', 'a', 'c']
la1=['k','p']
#list.append(obj) 	在列表末尾添加新的对象
la.append('g') #['a', 'b', 'a', 'c', 'g']
#在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
la.extend(la1)  #['a', 'b', 'a', 'c', 'g', 'k', 'p']
la.count('a') #2  list.count(obj) 统计某个元素在列表中出现的次数
la.index('b')  #1  list.index(obj) 从列表中找出某个值第一个匹配项的索引位置
la.insert(0,'x') # list.insert(index, obj) 	将对象插入列表
#ist.pop([index=-1]) 	移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
la.pop()  #['x', 'a', 'b', 'a', 'c', 'g', 'k']
la.pop(0)  #['a', 'b', 'a', 'c', 'g', 'k']
#list.remove(obj) 	移除列表中某个值的第一个匹配项
la.remove('a')  #['b', 'a', 'c', 'g', 'k']
la.reverse() #['k', 'g', 'c', 'a', 'b'] 反向列表中元素
#list.sort(cmp=None, key=None, reverse=False) 	对原列表进行排序
la.sort()#['a', 'b', 'c', 'g', 'k']

元组-字典

元组tuple 字典

元组的元素不能修改，创建空元组tp=(), 只有一个元素tp=(1,);元组与字符串类似，下标索引从0开始，可以进行截取，组合等。

可变容器且可存储任意类型对象，字典的每个键值 key=>value : 分割，每个键值对之间用逗号 , 分割，整个字典在 {} 中 ,eg: d = {key1 : v1, key2 : v2 }键一般是唯一的，如果重复最后的一个键值对会替换前面的，值不需要唯一.

#tuple元组操作
tup=(1,2,3)       #创建
tup[0]            #1  下标获取
tup[:]     #(1,2,3)
tup[1:2]   #(2,) 
tup[::-1]  #(3,2,1)
#tup[0]=10  #TypeError不支持修改
del tup  #元素不可删除，可删除整个元组
len((1,2,3)) #3 计算元素个数
(1,2)+(2,) #(1, 2, 2) 连接
(1,)*3     #(1,1,1) 复制
3 in (1,2,3)  #True 元素存在否
for i in (1,2,3): print(1)
max((1,2,3)) #3 求最大最小数据类型要一致
#min(('1',2,3)) #TypeError

#dict元组操作
dict = {'a': 1, 'b': 2}  #创建
dict['a']           #key获取val
#dict['0']           #KeyError
dict['a']=0   #{'a': 0, 'b': '3'} 更新
dict['c']=3   #{'a': 0, 'b': '3', 'c': 0}
del dict['c'] #{'a': 0, 'b': '3'}
dict.clear()  #{} 清空
del dict      #删除字典
d1={'a':1,'b':2}
#dict1={[1,2]:1} #key是不可变
d1.keys()   #dict_keys(['a', 'b'])
d1.values() #dict_values([1, 2])
d1.items()  #dict_items([('a', 1), ('b', 2)])

集合set

集合（Set）是一个无序的不重复元素序列，可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

元素无序、元素不可更改、元素类型可以是各种类型、集合不允许有重复元素

#集合set
sp={1,2,3,1}    #{1, 2, 3} 去重
a=set('abcaf') #{'c', 'b', 'a','f'}
b=set('abcde') 
a-b        #{'f'} 集合a中包含而集合b中不包含的元素
a|b        #{'b', 'f', 'c', 'e', 'a', 'd'} 集合a或b中包含的所有元素
a&b        #{'a', 'c', 'b'} 集合a和b中都包含了的元素
a^b        #{'d', 'f', 'e'} 不同时包含于a和b的元素
#添加元素
#s.add(x) 将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作
a.add('r') #{'r', 'b', 'a', 'f', 'c'} 元素顺序每一次输出不一定一致
#s.update(x) 且参数可以是列表，元组，字典等
a.update('x') #{'x', 'f', 'a', 'b', 'r', 'c'}
a.update(['y','z']) #{'y', 'a', 'f', 'c', 'x', 'z', 'r', 'b'}
#移除元素
a.remove('x') #{'c', 'y', 'z', 'b', 'a', 'f', 'r'}
#a.remove('x') #KeyError: 'x'
a.discard('y') #{'z', 'r', 'a', 'b', 'f', 'c'}
a.discard('y') #不存在也不会报错
len(a) #6
'x' in a  #判断元素是否在集合中存在
print(a.difference(b)) #{'f', 'r', 'z'} 返回多个集合的差集
print(a.intersection(b)) #{'c', 'a', 'b'} 返回集合的交集
print(a.isdisjoint(b))  #False 判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。
print(a.issubset(b))    #False 判断指定集合是否为该方法参数集合的子集。