python的基本语法-CSDN博客

本文链接：https://blog.csdn.net/m0_73820145/article/details/139050597

序列的通用操作

函数	描述	备注
len(item)	计算容器中元素个数
del(item)	删除变量	del有两种方式
max(item)	返回容器中元素最大值	如果是字典，只针对key比较
min(item)	返回容器中元素最小值	如果是字典，只针对key比较

描述	Pytthon表达式	结果	支持的数据类型
切片	“0123456789”[::-2]	“97531”	字符串、列表、元组

运算符	Python表达式	结果	描述	支持的数据类型
+	[1,2]+[3,4]	[1,2,3,4]	合并	字符串、列表、元组
*	[“Hi!”]*4	[“Hi!”,“Hi!”,“Hi!”,“Hi!”]	重复	字符串、列表、元组
in	3 in (1,2,3)	True	元素是否存在	字符串、列表、元组、字典
not in	4 in (1,2,3)	True	元素是否不存在	字符串、列表、元组、字典
> >= == < <=	(1,2,3) < (2,2,3)	True	元素比较	字符串、列表、元组

列表

语法: 列表名 = [元素1， 元素2， 元素3， …]

内置函数

len(list) max(list) min(list)
del list

# 添加元素
list.append(value)

# 添加列表
list.extend([1, 2, 3, ...])

# 插入元素
list.insert(__index, __object)

# 删除元素(根据索引删除)
list.pop(__index)
# 删除元素(根据元素删除[只删除第一个搜到的])
list.remove(__value)

# 清空元素
list.clear()

列表生成式

list(range(1,11))
[x**2 for x in range(1, 10)]
[i for i in range(1,100) if i % 10 == 0]
[str(x) for x in range(1, 10)]
[int(x) for x in list(‘123456789’)]

元组

Tuple(元组)与列表类似，但是元组的元素不能修改
元组表示多个元组组成的序列

使用（）定义

tuple = (1, 2, 3, True, "hello")
tuple = (1, ) # 元组里只有一个元组时，加一个逗号

元组的通用操作

索引：tp[__index]
切片：tp[::]
长度：len(tp)
最大值，最小值：max(tp), min(tp)
删除：del tp
加法(拼接)：tp1+tp2
*号：tp*num
in：同上

元组的常用方法

tp.count(__value)
tp.index(__value, __start, __stop)

元组的遍历

for value in tp: print(value)
for idx, val in enumerate(tp): print(idx, val)
for i in range(len(tp)): print(i, tp[i])

range

系统提供(在builtins.py中)的内建函数 range([start, ]end[, step=1])，生成一个等差序列[start, end)
序列属于不可变序列，不支持元素修改，不支持+和*操作
底层使用迭代器的方式节省内存，而不是一次性生成

字符串

序列的通用操作

for val in s1: print(val)
for idx, val in enumerate(s1): print(idx, val)
for i in range(len(s1)): print(i, s1[i])

字符串的遍历

for val in s1: print(val)
for idx, val in enumerate(s1): print(idx, val)
for i in range(len(s1)): print(i, s1[i])

类型转换

int–>str
list–>str
tuple–>str

常用方法

判断大小写：s1.islower()，s1.isupper()，s1.is…
计数：s1.count(__sub)
s1.strip() 相当于trim，去掉两边的空格
分割字符串(返回是列表)：s1.split(__sub)
s1.find(__sub, [__start], [__end])
“#”.join([‘111’,‘222’,‘333’]) 111#222#333
s1.lower()

字典（dict）

dictionary（字典）是除列表以外最灵活的数据类型
字典同样可以用来存储多个数据
通常用户存储描述一个物体的相关信息
与列表的区别：列表是有序的对象集合，字典是无序的对象集合
key只能是不可变类型

字典的创建

d = {
	'a':'b', #键值对
	'c':False,
	'a':'c', #键重复，会覆盖之前的值
}
d = {}
d = dict()
d['height'] = 170 # 新增键值对
print(d['name']) #获取键值对
d['c'] = True #修改键值对
del d #删除字典
print('name' in d) #判断 键 有没有这个

字典的遍历

for i in d: print(i, d[i])
d.items()是dict_items类型，类似列表但不是
for k, v in d.items(): print(k, v)
for k in d.keys(): print(k)
for v in d.values(): print(v)

字典的常用方法

d.items
d.values()
d.keys()
d.pop(__key)
清空：d.clear()
拷贝一份：d.copy()
d.get(__key) 【若没有返回None】
d.popitem()【弹出后面的一个】
拼接：d.update({‘age’:18})

集合（set）

不允许有重复元素，如果添加重复元素，则会自动过滤，可以进行交集、并集的运算
是一种无序且无重复元素的数据结构
与dict类似，是一组key的集合（不存储value）

集合的创建

s = set()
s = {1, 2, 3, 4, 1, 2} # {1, 2, 3, 4} 
s = set(__list)
s = set(__tuple)
s = set(__str)
s = set(__dict) # 存字典时只会存key
# ----------------------- #
1 in s
len(s)
min(s)
不支持索引

集合的遍历

for i in s: print(i)

常用的方法

加入：s.update(__s)
s.copy()
s.remove(__element)
s.add(__element)
s.pop()
交集、并集：s1&s2 s1|s2
列表去重：socre = [1, 2, 3, 3]

可变类型 & 不可变类型

不可变类型

数字（例如：int, float, complex）
字符串（例如：str）
元组（例如：tuple）
布尔类型（例如：bool）

可变类型

列表（例如：list）
字典（例如：dict）
集合（例如：set）

异常

NameError：函数名拼写错误；变量名拼写错误；使用一个不存在的变量
SyntaxError：…
TypeError
AttributeError
KeyError：字典没找到key
IndexError：越界
ValueError
ZeroDivisionError

try:
	n = int(input("请输入一个数字"))
	n = 5 / n
except ZeroDivisionError as e:
	print('原始报错信息', e)
except:
	print('请输入一个数字')
else:
	print("运行没有被except语句捕获，执行else模块")
finally:
	print("无论如何，都要执行")

try:
	pwd = input("请输入你的密码")
	if len(pwd) < 8:
		raise Exception('密码的长度不够，请输入一个8位以上的密码')
except Exception as e:
	print(e)

函数

可变参数

def total(*args):
	print(args) #(1, 2, 3)
	res = 0
	for i in args:
		res += i
	return res
res = total(1,2,3)

def f(**kwargs): # 可变参数，接收字典
	for k, v in kwargs.items():
		print(k, v)
d={"1":"1"}
f(**d)

匿名函数

一种快速定义单行的最小函数，可以用在任何需要函数的地方

fun = lambda a, b : a + b
print(fun(1,2))
# ---
a = [1, 2, 3]
def f(x):
	return x ** 2
result = map(f,a)
result = map(lambda x:x**2, a)
print(list(result))

reduce

from functools import reduce
a = [1, 2, 3]
result = reduce(lambda x,y:x+y, a)
print(result)

filter 过滤

a = [1, 2, 4]
result = filter(lambda x:x%2==0, a)
print(list(result))

内置函数

模块

import ,
from … import …

random

import random
print(random.random()) # 随机小数
print(random.randint()) # 随机整数
print(random.randint(1, 100)) # 闭区间
print(random.choice(list1))
print(random.choice('hello'))
random.shuffle(list1)

re

import re
re.match(pattern, string)

time

import time
print(time.time()) #时间戳：1970年
print(time.localtime()) # 结构化的时间
print(time.localtime().tm_year)
print(time.strftime('%Y-%m-%d %H:%M:%S',time.localtime()))

turtle(绘图库)海龟

import turtle, time
pen = turtle.Turtle()
pen.speed(0) # 设置速度
pen.backward(100)
pen.forward(100)
pen.left(50) # 左转50度
pen.forward(100)
time.sleep(1)
pen.clear()
pen.write('hello', font=("Arial", 40, "normal"))
input()

socket

import socket
sk = socket.socket()
sk.bind(("0.0.0.0", 8999))
sk.listen(5)
conn, addr = sk.accept()
print(conn, addr)
accept_data = conn.recv(1024).decode('utf8')
send_data = '收到'
conn.send(send_data.encode('utf8'))

import socket
sk = socket.socket()
sk.connect(("127.0.0.1", 8999))
send_data = input("输入要发送的内容")
sk.send(send_data.encode('utf8'))
accept_data = sk.recv(1024)
print(accept_data.decode('utf8'))

安装第三方库

pip list
pip install --upgrade pip
pip install pygame
pip config set global.index-url https://mirrors.aliyun.com/pypi/simple
pip config get global.index-url
pip uninstall pygame

文件

f = open('test.txt', mode='r', encodeing='utf-8') # 打开文件
context = f.read(__n) # 读取文件
context = f.readline() # 每次读取一行
context = f.readlines() # 每行存到列表里
f.close() # 关闭文件

# -------
f = open('test.txt', mode='w',encoding='utf-8')
f.write('你好')
f.writelines(list)
f.close()
# --------
with open('test.txt', mode='r', encoding=='utf-8') as f:
	context = f.read()
	print(context)

os获取路径

import os
path = os.getcwd() # 绝对路径

csv文件读取

csv文件

姓名,科目,成绩
a,python,10
b,java,20

csv读取

import csv
with open('data.csv',mode='r',encoding='utf-8') as f:
	cf = csv.reader(f)
	head = next(cf) # 获取表头
	print(head)
	for i in cf:
		print(i) # list

csv写入

import csv
with open('data.csv',mode='a',encoding='utf-8') as f:
	cf = csv.writer(f)
	cf.writerow(['tom','c',60])
	cf.writerows([[],...])

面向对象

类的定义

class ClassName(object):
	<statement-1)
	.
	.
	.
	<statement-N>

实例属性

class Player(object):
	def __init__(self, name, age, city):
		self.name = name # 实例属性
		self.age = age
		self.city = city
		pass
tom = Player("tom",18,"a")

使用 实例.__dict__ 可以以字典的形式打印所有属性

类属性

类似static修饰
不能被__dict__获取

在类中需要使用 类名.类属性 修改

class Player(object):
	numbers = 0 # 类属性
	def __init__(self, name, age, city):
		self.name = name # 实例属性
		self.age = age
		self.city = city
		Player.numbers += 1

实例方法

class Player(object):
	numbers = 0 # 类属性
	def __init__(self, name, age, city):
		self.name = name # 实例属性
		self.age = age
		self.city = city
		Player.numbers += 1
	def show(self):
		print(self.__dict__)

类方法

类似static修饰类中的函数
需要添加修饰器@classmethod

参数应为cls（class）

class Player(object):
	numbers = 0 # 类属性
	def __init__(self, name, age, city):
		self.name = name # 实例属性
		self.age = age
		self.city = city
		Player.numbers += 1
	def show(self):
		print(self.__dict__)
	@classmethod
	def get_player(cls):
		print('用户数量为%d'%cls.number)
		pass
Player.get_player()

静态方法

既不接收实例也不接收类作为参数。静态方法就像是定义在类之内的普通函数

使用场景：当你需要在类中定义一个与类和实例都无关的功能时。

class Player(object):
	numbers = 0 # 类属性
	def __init__(self, name, age, city):
		self.name = name # 实例属性
		self.age = age
		self.city = city
		Player.numbers += 1
	def show(self):
		print(self.__dict__)
	@classmethod
	def get_player(cls):
		print('用户数量为%d'%cls.number)
		pass
	@staticmethod
	def isvalid(**kwargs):
		if kwargs['age'] > 18:
			return True
		return False
		pass
d = {'name':'Tom', 'age':19, 'city':'a'}
Player.isvalid(**d)

类的继承

面向对象特点：继承、多态、封装

class VIP(Player):
	pass
a = VIP("Tom", 24, 'a')
a.show() # 体现了继承

class VIP(Player):
	# 构造函数重写
	def __init__(self, name, age, city, coin):
		super().__init__(name,age,city)
		self.coin = coin
	# 实例方法重写
	def show(self):
		...
a = VIP('Tom', 24, 'a', 123)
print(a.coin)

多态

class Animal(object):
	def speak(self):
		print('Animal')
class Cat(Animal):
	def speak(self):
		print('Cat')
class Dog(Animal):
	def speak(self):
		print('Dog')
def speak(object): # animal类型的实例
	if isinstance(object, Animal) == False:
		raise Exception('Error')
	object.speak()
a = Cat()
b = Dog()
speak(a)
speak(b)

封装

内部实现隐藏起来
实质是变量的改名采用 _类名_属性名，还是可以访问到的
可以使用get/set形式

class User(object):
	def __init__(self, name, age):
		self._name = name # 一个下划线受保护的变量，外界可以输出，但不能修改
		self.__age = age  # 两个下划线私有变量，外界无法输出
	def _show_infos(self):
		print('hello %s %d' %(self._name, self.__age))
	def __aa(self): #外界不能使用
		pass
	@property
	def age(self):
		return self.age
	@age.setter
	def age(self,age):
		if isinstance(age, int):
			self.__age = age
		else:
			raise Exception('Err')
a = User('Tom', 24)
print(a.age) # 采用了装饰器，这里直接当作变量用
a.age = 25 # 采用装饰器，直接修改

魔法方法

class User(object):
	def __init__(self, name):
		self.name = name
	def __str__(self):
		return 'hello'
	def __add__(self, other):
		return self.name + other.name
	def __eq__(self, other):
		return self.name == other.name
	...
	
a = User('Tom')
print(a) # print会自动执行__str__方法
b = User('Jack')
print(a + b) # + 自动执行__add__方法
print(a == b) # = 自动执行__eq__方法
...