这里记录一下基础特性，方便后期查找|

环境

使用 venv 构建虚拟环境

python -m venv myenv

myenv是环境名字

激活环境

• Windows 命令提示符

myenv\Scripts\activate.bat

• Mac/Linux（Bash/Zsh）

source myenv/bin/activate

退出虚拟环境

deactivate

基础数据

字符串

在Python中引号括起的都是字符串，其中的引号可以是单引号，也可以是双引号，如下所示

name = 'xiaoYan'
or
name = "xiaoYan"

函数

title()

首字母大写显示

你可能希望程序将值 XiaoYan 、XIAOYAN 和 xiaoyan 视为同一个名字，并将它们都显示为Xiaoyan

name = 'xiaoYan'

print(name.title())

如果你需要买个单词的首字母大写例如输出:XiaoYan,那么你可以在源字符用空格分隔，如下：

name = 'xiao yan'

print(name.title())

lower()

大写显示

lower()

小写显示

字符串中使用变量

小写显示

first_name = "Lei"

last_name = "HuangYan"

full_name = f"{first_name} {last_name}"

print(full_name)

程序将会输出: Lei HuangYan

注意

f字符串是Python 3.6引入的。如果你使用的是Python 3.5或更早的版本 (用这么低的版本，建议升级哦) 要使用方法format()方法，而非这种f语法。

要使用方法format()，可在圆括号内列出要在字符串中使用的变量。对于每个变量，都通过一对花括号来引用。这样将按顺序将这些花括号替换为圆括号内列出的变量的值，如下所示：

full_name = "{} {}".format(first_name, last_name)

lstrip()

去开头(左边)空格

strip()

去两边（开头末尾）空格

rstrip()

去末尾(右边)空格

数

整数

分别使用加法、减法、乘法和除法运算，结果都为数字16

#加
print(13+3)
#减
print(19-3)
#乘
print(2*8)
#左移-位运算 
# 00100 == 4
# 10000 == 16
print(4<<2)
#平方
print( 4 ** 2)

浮点数

任意两个数相除时，结果总是浮点数，即便这两个数都是整数且能整除

print(16/2)
print(16>>1)

数中的下划线

Python 3.6和更高的版本支持。

书写很大的数时，可使用下划线将其中的数字分组，使其更清晰易读

#当你打印这种使用下划线定义的数时，Python不会打印其中的下划线
universe_age = 14_000_000_000
print(universe_age)

同时给多个变量赋值

可在一行代码中给多个变量赋值，助于缩短程序并提高其可读性。 这种做法最常用于将一系列数赋给一组变量。

x, y, z = 0, 0, 0

常量

类似于变量，但其值在程序的整个生命周期内保持不变。Python没有内置的常量类型，通常要指出应将特定的变量视为常量，可将其字母全部大写：

MAX_CONNECTIONS = 5000

列表

由一系列按特定顺序排列的元素组成。 你可以将任何东西加入列表中，其中的元素之间可以没有任何关系。 类似于数组

friends = ['huishao','saoqiu','maokeng']

列表修改

list[index] = 'new item' 可根据下标修改对应的值

friends[0] = 'Li MingHui'

列表插入

list.append('item') 追加到末尾

friends.append("Li Peng")

list.insert(index,'item') 指定下标位置插入

friends.insert(2,"Xiao Kai")

列表删除

del list[index] 指定下标位置删除

del friends[2]

list.pop(index) ,删除指定下标元素，并返回该元素的值。如果index为空或者不写，那么删除列表末尾元素。

print(f'第一个工作的人是:{friends.pop()}')

print(f'{friends.pop(1)} 是第2个来的人，他也去工作了')

list.remove('val') 删除元素值 remove 只删除第一个指定的值。如果要删除的值可能在列表中出现多次，就需要使用循环来确保将每个值都删除。

friends.remove('maokeng')

得到列表长度

list.len() 长度

friends.len()

列表排序

永久排序

sort() 永久排序，会改变列表，且无法恢复原来的排序位置

#按字母顺序排序
friends.sort()

#按反字母顺序排序
friends.sort(reverse=True)

临时排序

sorted() 临时排序

#按字母顺序排序
sorted(friends)

#按反字母顺序排序
sorted(friends,reverse=True)

倒序

list.reverse() 倒序

friends.reverse()

遍历

for item in list:

for item in friends:
    print(item)

数值列表

range(startIndex,endIndex,step) 创建一个从 startIndex 开始，endIndex 结束（不包括endIndex）的列表

• startIndex 开始下标,如果不指定，默认0
• endIndex 结束下标
• step 步长

for item in range(1,5):
    print(item)

上述代码，将打印:1 2 3 4

步长

for item in range(1,5,2):
    print(item)

上述代码，将打印:1 3

转列表

list( range(1,5) )

统计

最小值

min( range(1,5) )

最大值

max( range(1,5) )

求和

sum( range(1,5) )

列表解析

通常我们要基于现有列表生成一个新列表的时候，通常会定义一个新列表新列表，然后遍历现有列表的值，重新插入的到新列表。如下

newList = []
for item in range(1, 10):
  newList.append(item ** 2)
  
print(newList)

如果你觉得上面代码过于繁琐，你可以采用如下写法得到同样的结果

squares = [item ** 2 for item in range(1, 10)]

print(squares)

切片

list[startIndex:endIndex]

• startIndex: 切片开始下标,
  • 如果不指定,将从头开始
  • 如果为负数,返回后几位
• endIndex: 切片结束下标
  • 如果不指定为列表尾部

示例:

nums = list(range(1, 10))

#输出前3个元素
print(nums[:3])

#输出前第2~3个元素
print(nums[1:3])

#输出后3位
print(nums[-3:])

#输出前第2位~列表结尾
print(nums[1:])

#从开始到结尾
print(nums[:])

如何复制

如果我们想要复制一个列表，通常会采用直接赋值的方式，如下

nums = list(range(1, 10))

numsCopy = nums

nums.append(11)
print("num 增加11")
print(nums)
print(numsCopy)

numsCopy.append(12)
print("numCopy 增加12")
print(nums)
print(numsCopy)

但是你会发现: numsCopy 和nums 完全一致。

这种语法实际上是让Python将新变量 numsCopy 关联到已与nums相关联的列表，因此这两个变量指向同一个列表。所以他们完全一致

鉴于此,我们可以使用切片list[:]达到复制效果

nums = list(range(1, 10))

numsCopy = nums[:]

nums.append(11)
print("num 增加11")
print(nums)
print(numsCopy)

numsCopy.append(12)
print("numCopy 增加12")
print(nums)
print(numsCopy)

元组

笔记

列表非常适合用于存储在程序运行期间可能变化的数据集。列表是可以修改的，这对处理网站的用户列表或游戏中的角色列表至关重要。

然而，有时候你需要创建一系列不可修改的元素，元组可以满足这种需求。

Python将不能修改的值称为不可变的 ，而不可变的列表被称为元组

定义元组

元组看起来和列表非常相似，但不同于列表用[]表示,元组的约定是用()表示。定义元组后，可以像列表一样用下标访问。

注意

严格地说，元组是由逗号标识的，圆括号只是让元组看起来更整洁、更清晰。如果你要定义只包含一个元素的元组，必须在这个元素后面加上逗号：

my_t = (3,)

创建只包含一个元素的元组通常没有意义，但自动生成的元组有可能只有一个元素。

元组的使用

元组的使用和列表类似，只是不能修改

元组的重新赋值

元组的值虽然不能改变，但是可以给元组重新赋值

games = ('LOL','Genshin')
print(games)

games = ('Elden Ring','Sekiro: Shadows Die Twice')
print(games)

IF判断

title  = 'fail'

# 相等
if title == 'success':
    print("成功")
else :
    print("失败")

# and    
op = 1    
if title == 'success' and op == 1:
    print("成功")
else :
    print("失败")
    
# or  
if title == 'success' or op == 1:
    print("成功")
else :
    print("失败")

# in
if op  in range(0,5):
    print("成功")
else :
    print("失败")

# not in
if op  not  in range(0,5):
    print("成功")
else :
    print("失败")
    

if op  not  in range(0,5):  print('成功')

if op in range(0, 5):
    print('0-4')
elif op in range(5, 10):
    print('5-10')
else:
    print('other')

# 判断列表    

goods = []
if goods:  print(goods)
else:
    print("没有商品了")


if len(goods)==0:
    print("没有商品了")
else:
    print(goods)

字典

笔记

在Python中，字典 是一系列键值对 。 每个键都与一个值相关联，你可使用键来访问相关联的值。与键相关联的值可以是数、字符串、列表乃至字典。事实上，可将任何Python对象用作字典中的值。

字典用放在花括号{}中的一系列键值对表示，如前面的示例所示： user = {'name': 'Yae Miko', 'sex': '女'}

得到字典值

根据键得到值 dict[key]=val，当值不存在时，会出现异常

hero = {'name': 'Yae Miko', 'sex': '女'}
print(hero['name'])

print(hero.get('star'))
if hero.get('star') == None:
    print("没有此属性")
else:
    print("很难评价")

使用get()得到值 dict.get(key)=val，当值不存在时，返回None

if hero.get('star') == None:
    print("没有此属性")
else:
    print("很难评价")

设置字典值

hero = {'name': 'Yae Miko', 'sex': '女','star':'5'}

print(hero['name'])

ch_name = 'ch_name'

hero[ch_name] = '八重神子'
print(hero[ch_name])

删除字典值

hero = {'name': 'Yae Miko', 'sex': '女','star':'5'}

print(hero)
del hero['start']
print(hero)

遍历字典

items 得到字典项

#拆包
for key,val in hero.items():
    print(key,":",val)

# 通过item下标获取
for item in hero.items():
    print(item[0],item[1])

values 得到字典值

for item in hero.values():
    print(item)

keys 得到字典key

for item in hero.keys():
    print(item)

多种数据类型组合遍历

lol = {'name': 'LOL', 'heroes': [{"name": "放逐之刃"}, {"name": "无双剑姬"}, {"name": "刀锋舞者"}, {"name": "青钢影"}
    , {"name": "灵罗娃娃"}], 'details': {"type": "moba"}}

genshin = {'name': 'GenShin',
           'heroes': [{"name": "Yae Miko"}, {"name":"宵宫"}, {"name": "莫娜"}, {"name": "刻晴"}, {"name": "甘雨"}]
    , 'details': {"type": "RPG"}}

games = [lol, genshin]

for game in games:
    print(f"当前游戏{game.get('name')},游戏类型:{game.get('details').get('type')}")
    for hero in game.get("heroes"):
        print(f"拥有英雄:{hero.get('name')}")
    print()

用户输入

component = input("清输入你的成分: ")

print("你的成分是:{component}")

While循环

基础用法

循环打印1~5

current_number = 1
while current_number <= 5:
    print(current_number)
    current_number += 1

退出循环

更改标识退出

prompt = "\n我是一个复读机，你说啥我说啥"
prompt += "\n输入 'q' 退出程序:"

message = ""
while message != 'q':
    message = input(prompt)
    print(f"重复: {message}")

prompt = "\n我是一个复读机，你说啥我说啥"
prompt += "\n输入 'q' 退出程序:"

active = True
while active:
    message = input(prompt)
    if message == 'quit':
        active = False
    else:
        print(f"重复: {message}")

break退出

prompt = "\n我是一个复读机，你说啥我说啥"
prompt += "\n输入 'q' 退出程序:"

while True:
    message = input(prompt)
    if message == 'quit':
        break
    else:
        print(f"重复: {message}")

continue 跳出当前循环执行下一次

current_number = 0
while current_number < 10:
    current_number += 1
    if current_number % 2 == 0:
        print("能整除2跳过，不打印值")
        continue
        
    print(current_number)

函数

笔记

函数是带名字的代码块，用于完成具体的工作。要执行函数定义的特定任务，可调用 该函数。需要在程序中多次执行同一项任务时，无须反复编写完成该任务的代码，

定义

定义一个run方法

def run():
    print("快跑啊")
#执行run函数    
run()

注意

函数执行代码，必须要放在函数定义之后

带参函数

单个参数

def play(name):
    print(f"在和{name}玩耍")


play("Yae Miko")

实参和形参

前面定义函数 play()时，要求给变量 name指定一个值。调用这个函数并提供这种信息（人名）时，它将打印相应的问候语。

在函数 play() 的定义中，变量 name 是一个形参（parameter），即函数完成工作所需的信息。

在代码 play("Yae Miko") 中，值 Yae Miko是一个实参（argument），即调用函数时传递给函数的信息。

调用函数时，将要让函数使用的信息放在圆括号内。在play("Yae Miko")中，将实参Yae Miko传递给了函数play()，这个值被赋给了形参 name

多个参数

通用传参

如果方法有多个参数，实参的和形参的值按位置一一对应。

def play(name,game):
    print(f"在和{name}玩{game}")

play("Yae Miko",'LOL')

关键字实参数

为了防止值传入错五，使用关键字实参，可无视参数传递顺序

def play(name,game):
    print(f"在和{name}玩{game}")

play(game = 'LOL',name ="Yae Miko")

默认值

def play(game,name='八重神子'):
    print(f"在和{name}玩{game}")

#使用默认值
play('LOL')

#覆写默认值
play('LOL','Yae Miko')

注意

使用默认值时，必须先在形参列表中列出没有默认值的形参，再列出有默认值的实参。

也就是说，有默认值的参数必须定义在没有默认值的参数后

返回值

用return 将语句值返回到调用函数的代码行

def select(code):
    hero =['Yea Miko' ,'wolf' ,'Ali']
    return  hero[int(code) % len(hero)]

code =input("请输入一个系统将给你随机一个英雄:")

print(f"你选择的英雄是:{select(code)}")

传递列表

同步修改

def  handel_list(list):
    list.append("S")

souList = [1,2,3]
handel_list(souList)
print(souList)

不同步修改

def  handel_list(list):
    list.append("S")

souList = [1,2,3]
handel_list(souList[:])
print(souList)

传递任意参数

定义形参时 用*修饰,代表任意数量,调用时可传递任意数量实参。

* 只能修饰最后一个形参

def  handel_list(cmd,*params):
    print(f"今天我们:{cmd}")
    for item in params:
        print(f"{item}:上线")


handel_list("打游戏",'禁撸小分队1号','禁撸小分队2号','禁撸小分队3号','禁撸小分队4号','禁撸小分队5号')

传递任意关键字参数

定义形参时 用*修饰,代表任意数量,调用时可传递任意数量实参。

* 只能修饰最后一个形参

def handel_list(cmd, **params):
    print(f"今天我们:{cmd} {params}")
    for key, val in params.items():
        print(f"{val}:上线")


handel_list("打游戏", no1='禁撸小分队1号', no2='禁撸小分队2号', no3='禁撸小分队3号', no4='禁撸小分队4号',
            no5='禁撸小分队5号')

导入模块

全部导入

定义 function.py

def run():
    print("快跑啊")

定义 main.py

import  function

function.run()

指定函数

from function import run

run()

指定函数并给函数添加别名

from function import run as  thisRun

thisRun()

指定别名

指定别名后就只能用别名调用，用引入模块名报错会报错

import function as fun

fun.run()

导入模块所有函数

from function import *

run()

类

笔记

面向对象编程是最有效的软件编写方法之一。

在面向对象编程中，你编写表示现实世界中的事物和情景的类，并基于这些类来创建对象。

编写类时，你定义一大类对象都有的通用行为。

基于类创建对象时，每个对象都自动具备这种通用行为，然后可根据需要赋予每个对象独特的个性。

使用面向对象编程可模拟现实情景，其逼真程度达到了令人惊讶的地步。

根据类来创建对象称为实例化

定义类

class Car:

    def __init__(self, brand, model, type):
        self.brand = brand
        self.model = model
        self.type = type

    def run(self):
        print(f"传统车:{self.brand} {self.model} 类型:{self.type}")
        
        
myCar = Car("领克", '03', '油车')
myCar.run()

继承类

## 定义类
class Battery:

    def __init__(self, battery_size=75):
        self.battery_size = battery_size
        
#继承
class ElectricCar(Car):

    def __init__(self, brand, model):
        super().__init__(brand, model, '电动车')
        ## 将一个类作为类的属性
        self.battery = Battery()

    #重写父类方法
    def run(self):
        print(f"新能源:{self.brand} {self.model} 类型:{self.type},剩余电量:{self.battery.battery_size}")


myElectricCar = ElectricCar('Tesla', 'model S')
myElectricCar.run()

导入类

定义类 Car.py 内容如下

class Car:

    def __init__(self, brand, model, type):
        self.brand = brand
        self.model = model
        self.type = type

    def run(self):
        print(f"传统车:{self.brand} {self.model} 类型:{self.type}")


class Battery:

    def __init__(self, battery_size=75):
        self.battery_size = battery_size


class ElectricCar(Car):

    def __init__(self, brand, model):
        super().__init__(brand, model, '电动车')
        self.battery = Battery()

    def run(self):
        print(f"新能源:{self.brand} {self.model} 类型:{self.type},剩余电量:{self.battery.battery_size}")

新建 run.py 内容如下

from car import Car
from car import ElectricCar


myCar = Car("领克", '03', '油车')
myCar.run()

myElectricCar = ElectricCar('Tesla', 'model S')
myElectricCar.run()

或者

一个模块导入多个类

from car import Car,ElectricCar


myCar = Car("领克", '03', '油车')
myCar.run()

myElectricCar = ElectricCar('Tesla', 'model S')
myElectricCar.run()

或者

导入整个模块

import car

myCar = car.Car("领克", '03', '油车')
myCar.run()

myElectricCar = car.ElectricCar('Tesla', 'model S')
myElectricCar.run()

导入模块中的所有类

from car import *

myCar = Car("领克", '03', '油车')
myCar.run()

myElectricCar = ElectricCar('Tesla', 'model S')
myElectricCar.run()

使用别名

from car import Car as Car,ElectricCar as ECar


myCar = Car("领克", '03', '油车')
myCar.run()

myElectricCar = ECar('Tesla', 'model S')
myElectricCar.run()

导入其他模块

from random import randint,choice
#生成一个指定范围的随机数
num = randint(1, 6)

print(num)


#列表或元组作为参数，并随机返回其中的一个元素：
players = ['charles', 'martina', 'michael', 'florence', 'eli']
first_up = choice(players)
print(first_up)

文件

open函数是 Python 内置函数之一，用于打开文件并返回一个文件对象。

函数的参数进行解释如下：

• file：要打开的文件名或文件路径。
• mode：打开文件的模式，默认为 'r'（只读模式）。常见的模式包括：
  • 'r'：只读模式
  • 'w'：写入模式，会覆盖原有内容
  • 'x'：创建并写入模式，但如果文件已存在则报错
  • 'a'：追加模式，在文件末尾追加内容
  • 'b'：二进制模式
  • 't'：文本模式（默认）
• buffering：设置缓冲策略，控制是否使用缓冲或使用何种缓冲大小。默认值为 None，表示系统默认值。
• encoding：指定文件编码方式，用于读取和写入文件。例如，encoding='utf-8'。
• errors：指定编码错误处理的策略。默认为 None，表示使用系统默认策略。
• newline：用于控制文本模式下的换行符处理。默认为 None，表示使用系统默认的换行符处理。
• closefd：关闭文件描述符的标志。默认为 True，表示在文件关闭时也关闭文件描述符。

读文件

with open('pi_digits.txt') as file_object:
    contents = file_object.read()
# print(contents)

使读出的文件和原有一致

# read()到达文件末尾时返回一个空字符串，而将这个空字符串显示出来时就是一个空行,想要输出原文件用 rstrip() 处理
with open('pi_digits.txt') as file_object:
    for line in file_object:
        print(line.rstrip())

将读取到的文件保存到lines，后续在with代码块外使用

filename = 'pi_digits.txt'
with open(filename) as file_object:
    lines = file_object.readlines()

for line in lines:
    print(line.rstrip())

写文件

注意

Python只能将字符串写入文本文件。要将数值数据存储到文本文件中，必须先使用函数str() 将其转换为字符串格式。

写入模式

filename = 'pi_digits.txt'
with open(filename, 'w', encoding='utf-8') as file_object:
    for val in range(1 ,100):
        file_object.write(f"写入内容:{val}\n")

追加模式

filename = 'pi_digits.txt'
with open(filename, 'a', encoding='utf-8') as file_object:
    for val in range(1 ,100):
        if val==1:
            file_object.write("下面插入附加内容\n\n")
        file_object.write(f"附加内容:{val}\n")

异常

Python使用称为异常的特殊对象来管理程序执行期间发生的错误。

每当发生让Python不知所措的错误时，它都会创建一个异常对象。

如果你编写了处理该异常的代码，程序将继续运行；如果未对异常进行处理，程序将停止并显示traceback，其中包含有关异常的报告。

异常是使用try-except 代码块处理的。

try-except 代码块让Python执行指定的操作，同时告诉Python发生异常时怎么办。

使用try-except 代码块时，即便出现异常，程序也将继续运行：显示你编写的友好的错误消息，而不是令用户迷惑的traceback。

try-except

import traceback
from random  import randint

while  True:
    num = int(input("请输入一个数:"))
    rnum = randint(0, 100)
    try:
        print(f"计算的结果为:{rnum / num}")
    except Exception:
        print(f"输入值异常{num}")

try-except-else

import traceback
from random  import randint

while  True:
    num = int(input("请输入一个数:"))
    rnum = randint(0, 100)
    try:
        print(f"计算的结果为:{rnum / num}")
    except Exception:
        print(f"输入值异常{num}")
    else:
        print(f"正常值{num}")

打印异常值

try:
    #此处代码省略
except Exception:
    traceback.print_exc()
else:
    print(f"正常值{num}")
        
        

静默失败

try:
    #此处代码省略
except Exception:
    pass
else:
    print(f"正常值{num}")