Python基础语法

目录

• • Python数据类型
  • [Python 序列数据结构](#Python 序列数据结构)
  • [Python 控制语句](#Python 控制语句)
  • [Python 函数与模块](#Python 函数与模块)
  • [Python 面向对象设计](#Python 面向对象设计)
  • 其他

变量名必须是大小写英文，数字和 _ 的组合，且不能用数字开头；

常量通常用全部大写的变量名表示；

inf 代表无限大；

在python中除法有2种：
1. / 除法计算结果是浮点数
9 / 3 # 结果 3.0 

2. // 除法计算结果是整数
9 // 3 # 结果 3

Python数据类型

python提供了ord() 函数获取字符的整数表示，chr() 函数把编码转换为对应的字符：

ord('a') # 结果 97
chr(97) # 结果 a

布尔类型有以下运算

# and 运算
True and True # 结果是 True

# or 运算
Ture or False # 结果是 True

# not(非)运算
not True # 结果是 False

空值是python中的一个特殊值，用None表示；

字符串的三种定义方式：

# 双引号定义
s1 = "Hello"

# 单引号定义
s1 = 'hello'

# 三引号定义（多行字符串）
s1 = """
    尊敬的客户：
      感谢你选择我们公司的产品
    """

字符串格式化

第一种：通过 %占位符 的形式完成字符串和变量的快速拼接。（其中 % 表示我要占位，s表示将变量转为字符串放入占位的位置）
s1 = "人生苦短"
s2 = "及时行乐"
print("我说：%s ，%s" % (s1,s2))

第二种：f"内容{变量/表达式}" 的形式来完成快速格式化 （推荐）
print(f"我说：{s1},{s2}")

常见的占位符号：
%d 整数
%f 浮点数
%s 字符串
%x 十六进制整数

字符串常用方法

# 字符串切片
string = "Hello,World!"
sub_string = string[7:12]  # 切取 "World"
print(sub_string)  # 输出 "World"

string = "Hello,World!"
sub_string = string[-6:]  # 从倒数第6个字符开始切取到末尾
print(sub_string)  # 输出 "World!"

string = "Hello,World!"
sub_string = string[::2]  # 每隔一个字符切取一次
print(sub_string)  # 输出 "HloWrd"


string = "Hello,World!"
sub_string = string[::-1]  # 逆序切取整个字符串
print(sub_string)  # 输出 "!dlroW,olleH"

类型转换：

•其他类型转为int类型：int(...)

•其他类型转为str类型：str(...)

•其他类型转为float类型：float(...)

•其他类型转为bool类型：bool(...)

Python 序列数据结构

list1 = [1,2,3,4,5,6,7]

# 切片语法：序列数据[开始索引：结束索引：步长] 不包含结束索引
list1[1:5] # 从第2个元素到第5个元素，结果 [2,3,4,5]

# 删除列表元素
del list1[2] # 删除索引为2的元素
list1.remove(3) # 删除元素为3
list1.pop(2) # 删除索引为2的元素

L = list(range(1,10)) # [1,2,3,4,5,6,7,8,9]

列表List 常用方法

tup3 = tup1+tup2 # 连接元组，创建一个新的元组

# 元组中的元素不允许删除，可以用del 删除整个元组
del tup

count()：统计指定元素的数量
index()：获取指定元素的索引，如果该元素不存在将报错


# 组包/解包
t1 = (5, 7, 9, 1)
t2 = 5, 7, 9, 1

# 基础解包
a, b, c, d = t1
# (*)扩展解包
x, *y, z = t2  # x为5，y为[7, 9]，z为1
s, *o = t2  # s为5，o为[7, 9, 1]
*o, e = t2  # o为[5, 7, 9]，e为1

# 定义tuple
t = () # 定义一个空的tuple
t = (1,) # 定义只有一个元素的tuple

dict = {'Name': '小米','Age': 17}

# 删除字典中的元素
del dict['Name'] # 删除 Name的元素
dict.clear() # 清空字典中的所有元素
del dict # 删除字典，用del删除后字典不再存在

# in 运算，判断某键是否在字典里
'Age' in dict # True

# dict.values() 获取字典中的所有值

# dict.items() 把字典中的每对key和value组成一个元组，并把这些元组放在列表中返回

# dict.get('Name',-1) # 如果key不存在，返回None，也可以自定义 返回-1

字典常见方法

可以使用 -（差集） |（并集） &（交集） ^ (异或)

集合Set常见方法

Python 控制语句

python的语句体式是用缩进形式来表示；

选择结构：

# if......elif......else
if 表达式：
  语句1
elif 表达式2：
  语句2
else：
  语句3

# match......case
day = input("请输入星期几(1-7)：")
match day:
    case "1":
        print("周一：工作会议日")
    case "2":
        print("周二：学习培训日")
    case "3":
        print("周三：项目开发日")
    case "4":
        print("周四：代码审查日")
    case "5":
        print("周五：总结规划日")
    case "6 | 7":
        print("周末放松")
    case _ :
        print("表示匹配到其他任何情况")
  

循环结构：
for item in Array：
  print(item)
else：# else 部分可选
  条件为False，循环正常结束时执行

while 条件表达式：
  循环语句1
  ......
else：# else 部分可选
  条件为False，循环正常结束时执行

Python 函数与模块

函数定义：

def 函数名（函数参数）：
  函数体
  return 表达式或值

python中变量都是弱类型，python会自动根据值来维护其类型；
如果没有return语句则自动返回 None；
不定长参数-位置传递 *args；
不定长参数-关键字传递 **kwargs；

# 函数的参数类型
- 普通参数：数字、布尔、字符串、列表、元组、集合、字典等；
- 特殊参数：函数；接收函数作为参数的函数称为高阶函数

# 匿名函数 lambda
lambda 参数列表：函数体

# 类型注解，Python是动态类型语言,添加的类型注解只是提示,并不是强制约束
变量：数据类型（例如 a:int = 2）

# 空函数，可以使用pass
def nop():
  pass

python内建了map（）和reduce（）

# map() 函数接收两个参数，一个是函数，一个是Iterable
# map将传入的函数依次作用到序列的每个元素，并把结果作为新的Iterator返回
def f(x):
  return x * x

r = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
print(list(r)) # 结果 [1, 4, 9, 16, 25, 36, 49, 64, 81]

# reduce() 
def add(x,y):
  return x+y

r = reduce(add,[1,3,5,7,9]) 
print(r) # 结果 25


# filter() 过滤
def is_odd(n):
    return n % 2 == 1

list(filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15])) # 结果: [1, 5, 9, 15]


# sorted() 排序，接收一个key函数来实现自定义的排序，例如按绝对值大小排序
# 如果要反向排序 可以传入第三个参数 reverse = True
sorted([36, 5, -12, 9, -21], key=abs, reverse=True)

def log(func):
    def wrapper(*args, **kw):
        print('call %s():' % func.__name__) # __name__ 可以拿到函数的名字
        return func(*args, **kw)
    return wrapper

# 把@log放到now()函数的定义处，相当于执行了语句 now = log(now)
# 由于log()是一个decorator，返回一个函数，所以，原来的now()函数仍然存在，
# 只是现在同名的now变量指向了新的函数，于是调用now()将执行新函数，即在log()函数中返回的wrapper()函数
@log
def now():
    print('2024-6-1')
    
now() 
# 结果
# call now():
# 2024-6-1

Python模块(module)：一个.py文件就是一个模块，模块是Python程序的基本组织单位。在模块中可以定义变量、函数、类，以及可执行的代码

# 模块导入方式
import 模块名
form 模块名 import 函数名1，函数名2，......
import 模块名 as 别名
form 模块名 import *

# __all__ 是一个模块级别的特殊变量
__all__控制的是 from ... import * 时，要导入的功能，例如：

__all__ = ['A','B']
from my import * # 只会导入__all__中包含的函数

Python 面向对象设计

类的定义：

class 类名：
  属性（成员变量）
  成员函数（成员方法）
  ......

例如：
class Person：
  num = 1
  def SayHello（self）:
    print('Hello!')

类名命名规范：遵循大驼峰命名法，每个单词的首字母都是大写；
self 代表当前创建的实例对象；

构造函数

def __init__(self,realpart,imagpart):
  self.realpart = realpart
  self.imagepart = imagpart

析构函数：用来释放对象占用的资源

def __del__(self):
  print（''）

魔法方法：

• 魔法方法是指Python中提供的以双下划线开头和结尾的特殊方法，用于定义类的特殊行为，比如：**init;**
• 魔法方法是不需要我们手动调用的，Python会在合适的时机自动调用;

私有成功与公有成员

在定义类的属性时，如果属性名以两个下划线 __ 开头，表示私有属性，否则是公有属性；
私有属性在类的外部不能直接访问，需要通过调用对象的公有成员方法来访问或者通过Python支持的特殊方法来访问：
对象名. _类名+私有成员

例如：访问Car类私有成员 __weight:
car1. _Car__weight

公有方法，私有方法，静态方法

class Fruit：
  price = 0
  def output(self): # 定义公共方法
    print(self.price)
    
  def __outputCity(self): # 定义私有方法
    print(self.__city)

  @ staticmethod # 定义静态方法
  def getPrice():
    return Fruit.price

类的继承

class 子类（父类）：
  子类成员

# 如果需要在子类中调用父类的方法，通过 父类.方法名() 的方式来实现且需要带上self参数变量
# 在类中调用普通函数时并不需要带上self参数

class Person(object): #父类必须继承 object，否则在子类中将无法使用super（）函数
    def __init__(self, name):
        self.setName(name)
    def setName(self, name):
        if type(name) != str:
            return
        self.name = name
    def show(self):
        print(self.name)

class Student(Person):
    def __init__(self, name, id):
        # 调用父类构造方法初始化子类的数据成员
        # 第一种：
        # Person.__init__(self, name)
        # 第二种：
        super(Student,self).__init__(name)
        self.id = id
    def show(self):
        Person.show(self)
        # super(Student,self).show()

重写父类方法

class Animal:
  def run(self):
    print('Animal is running......')
    
class Cat(Animal):
  def run(self):
    print('Cat is running......') # 方法重写

异常

抛出一个错误的实例：

raise语句抛出一个错误的实例：

def foo(s):
    n = int(s)
    if n==0:
        raise ValueError('invalid value: %s' % s)
    return 10 / n

def bar():
    try:
        foo('0')
    except ValueError as e:
        print('ValueError!')
        raise

bar()

其他

a = list()

# isinstance 判断一个变量是否为某个类型
isinstance(a,list) # 结果 True

# type 得到数据的类型
print(type(12)) # int
print(type('Hello')) # str


min()：获取最小值
max()：获取最大值
sum()：求和
len()：获取元素的个数


# 使用*进行解包操作，将数据容器解开成独立的元素
num_list1=[1,23,4]
num_list2 = [19,20,30,12,34,57]
print(*num_list1 , *num_list2) # 结果 1 23 4 19 20 30 12 34 57

# 判断有一个元素是否存在于列表中 in / not in
if num in list：
  ......

if num not in list：
  ......

# 转义
# python使用 r 表示''内部的字符串默认不转义 
print('\\\t\\') # 结果 \	\
print(r'\\\t\\') # 结果 \\\t\\

# 字符串内换行，如果写成程序并存为.py文件
print('''line1
line2
line3''')

input语句（函数）的功能就是获取键盘输入的数据，具体的用法为：s = input(提示信息)
print语句(函数)的功能就是将数据输出到控制台，具体语法为：print(数据..)

name = input("Enter your name: ")
print(f"Hello {name}")

range语句

作用：生成指定规则的数字序列

用法1：range(end) -> 获取一个从0开始，到end结束的数字序列（不含end本身）

• range(5)获取的数据就是 0,1,2,3,4

用法2：range(start,end) -> 获取一个从start开始，到end结束的数字序列（不含end本身）

• range(2,8)获取的数据就是 2,3,4,5,6,7

用法3：range(start,end,step) -> 获取一个从start开始，到end结束的数字序列，step步长（不含end本身）

• range(0,10,2)获取的数据就是 0,2,4,6,8