- 变量和简单数据类型
1.变量命名：字母、数字、下划线组成，不能数字开头，不能加空格，不能用python关键字、函数名作为变量名。
2.应用，将值ada赋予first_name：
first_name="ada"
3.字符串，区分大小写
print(first_name.title())#首字母大写
print(first_name.upper))#全部大写
print(first_name.lower())#全部小写
4.f字符串，设置格式，通过把花括号内的变量替换为其值来设置字符串的格式。用法f“{}”
first_name="ada"
last_name="lovelace"
Full_name=f"{first_name} {last_name}"
print(f"{Full_name.title()}") # Ada Lovelace 将Full_name.title()的值赋予Full_name.title()
print("{Full_name.title()}") # {Full_name.title()} python将“”中的变量当作字符输出
print({Full_name.title()}) #{'Ada Lovelace'}
print(Full_name.title()) #Ada Lovelace 输出的是变量Full_name.title()的值
print(first_name + last_name) #adaLovelace + 用于连接两个字符串，+运算符不能直接用于列表、元组或其他非数值和非字符串类型的数据结构。
5.添加/删除空白
添加空白：1.制表符：\t ；2.换行符：\n。
- 删除空白：删除末尾的空白：.rstrip()；删除开头的空白：.lstrip()；删除两端的空白：.strip()；
6.计算
整数：支持次序计算；乘方**；加减乘除+-*/；
浮点数：4/2=2.0；
下划线：python会忽略数中的下划线；
同时赋值：x,y,z=0,0,0
常量：一般定义常量为大写字母
|
bicycle=['terk','love','kk'] print(bicycle) too_expensive='kk' bicycle.remove(too_expensive) print(bicycle) print(f"\nA {too_expensive.title()} is too expensive to me.") ['terk', 'love', 'kk'] ['terk', 'love'] A Kk is too expensive to me. |
注释：#笑死我了
列表简介
定义：一系列按顺序排列的元素，用[]表示列表，逗号分割，如：bicycle = [‘giant’,‘terk’,‘evil’]
访问列表：print(bicycle[0])，索引从零开始，-1访问最后一个元素。
修改元素：bicycle[0]=‘duci’
末尾添加元素：bicycle.append(‘duci’)
插入元素：insert(0,’duci’)
删除元素：del bicycle[0] 删除字典：del bicyce[‘ ’]
术语弹出：first_bicycle=bicycle.pop(0) #将序列bicycle中的第一个元素弹出赋予first_bicycle
根据值删除元素：bicycle.remove(‘giant’)
组织列表
字母顺序永久排列：bicycle.sort()
列表临时排列：print(sorted(bicycle)) #只会在此次输出时临时排列； print(sorted(bicycle,reverse=True)) #排序会被永久保存在bicycle列表中
倒着打印列表：biclcle.reverse()
确定列表长度：len(bicycle)，sublime中不可用。
操作列表
|
bicycle = 'loke' bicycles = ['terk', 'love', 'diao'] |
遍历列表，bicycle为字符串，输出为单个字符，右侧输出为’l’,’o’,’k’,’e’。若为列表，则输出为列表中的每个元素。
深入循环：(两个print都缩进了，所以会导致两个print都进入循环，循环才需要缩进)
for bicycles in bicycle:
print(bicycles)
print(f"I love {bicycles.title()}")
创建数值列表：
for dsdsdsd in range(1,8): #指定从1开始，到8结束，但不包括8
print(f"\n {dsdsdsd}")
range()的用法：range(8) # 0～7
numbers=list(range(1,6))
print(numbers) #[1, 2, 3, 4, 5]
even_numbers=list(range(2,11,2)) # 从2开始数，不断加2，至11停止，输出1～10偶数
squares=[]
for value in range(1,11):
square=value**2
squares.append(square)
print(squares)
上述代码有些许繁琐，可不用中间值square，也可squares=[value**2 for value in range(1,11)]
列表名[表达式 +for循环] （for循环无冒号）
对数字进行统计处理
找出数列中的最大值max(数列)、最小值min(数列)、总和sum(数列)。
foolll=[llll for llll in range(1,1_000_001)] #llll为变量，foolll为数列
print(sum(foolll))
处理列表部分元素切片：
print(foolll[0:3]) #表示从零开始，到3结束，但不包括3
print(foolll[:3]) #表示从零开始
print(foolll[2:]) #表示从第三个元素到末尾
print(foolll[-3:]) #表示倒数三个元素
遍历切片：for player in foolll[:3] print(bicycle)
复制列表：player_1=players[0:3] #
player_1=players #表示列表player_1与列表player相关，两个列表指向同一个列表
-
-
元组deon=(20,50)
for deons in deon:
print(deons)
deon=(100,65)
for deons in deon:
print(deons)
-
定义：不可更改的列表成为元组
与列表区别：player=(1,2,3) #用小括号表示，逗号隔开
虽然不可修改元组变量，但对元组重新赋值是可以的。
-
- 设置代码格式
1.每一级缩进为四个空格
2.每一行不超过80字符，import this
-
if语句 （字符包括数字）age=20;age2=30
if age == 20 and age2!=20:
# and ；or的使用
print("I love sunchen")
else:
print("sunchen love me")
users=['a','b','c']
user='d'
if user not in users :
print ("I also love Sunchen")
car = 'subaru'
print("Is car == 'subarru'? I predict True. ")
print(car == 'subaru')
print(car == 'audi')
age = input("how old are you? ")
age = int(age)
print(age >= 18)
if 变量 == ‘字符’#相等== 不相等！= ； 判断是否相等：变量==’字符’，返回True or False
car.lower()==’audi’ #忽略大小写
数值比较：
检查元素是否在列表中：
20 in foolll 返回True or False 关键字：in；not in
-
- 布尔表达式(True and False)
- if elif else
python并不对 else有要求，可以省略，
if处理列表：
-
字典user_0 = {'username':'lucy','first':'fuck','last':'you'}
for key,value in user_0.items():
print(f"\nkey:{key}")
print(f"value:{value}")嵌套
alien_0 = {'color':'green','points':}
alien_1 = {'color':'red','points':67676}
alien_2 = {'color':'yellow','points':300}
aliens=[alien_0,alien_1,alien_2]
for alien in aliens:
print(alien)aliens = []
xxx = 62
for alien_number in range(10):
new_alien = {}
new_alien['color'] = 'green'
new_alien['points'] = f"{xxx}"
aliens.append(new_alien)
xxx += 955
print(aliens)
for alien in aliens[:]:
print(alien)
print("...")
print(f"Total number of aliens:{len(aliens)}")
for alien in aliens[:3]:
if alien['color'] == 'green':
alien['color'] = 'yellow'
alien['points'] = 'boolen'
for alien in aliens[0:5]:
print(alien)message = input("Tell me something, and I will repeat it back too you: ")
print(f"hello {message}")prompt = "If you tell us who you are, we can personalize the messages you see."
prompt += "\nWhat is you first name? "
name = input(prompt)
print(f"\nHello, {name}")prompt = "\nTell me something , "
prompt += "\nEnter 'quit' to e: "
message = ""
while message != 'quit':
message = input(prompt)
if message != ‘quit’print(message)
定义：一系列键值对，每个键都有与之对应的值，通过访问键来访问值。
例：alien_0={‘color’:’green’,’points’:’5’}
键和值之间用冒号（：）隔开，键值对之间用逗号（，）隔开
访问：alien_0[‘color’] #表示字典alien中与键’color’关联的值。
-
- 添加 键值对
alien_0[‘x_position’]=0
alien_0[‘y_position’]=25
表示添加了新的键’x_position’和’y_position’，以及与之对应的值0和25。
修改字典中的值：alien_0[‘color’]=yellow
get访问值：.get(‘键’,’键不存在时返回的值’)，用于可能不存在时的情况
遍历字典：for k,v in user_0.items() #for循环可用两个变量，分别赋予键和值。
point1["posibay"] = ["miushroom","extra cheese"] #字典中可存储列表、字典
遍历所有的键：for name in user_0.keys(): #同理遍历所有值.values()
-
- 嵌套
将列表存储在字典中、将字典存储在列表中，
生成10个alien，# Define a new dictionary for each alien
添加键值对，变量的数值可直接赋予键值对中的值，列表末尾附加，生成长列表，xxx自累加
切片前五个元素，
更改前三个元素的值，
- 用户输入和while循环
文本输入：message = input(“tell me some thing?”) #()中为提示语言，
若超过一行，首先将提示赋给一个变量，再将变量传递给input()，如：
数值输入：int()，massage=int(message)
用户选择退出程序，并且不打印出退出”quit”字符。
求模运算：6%5 #得出余数
break 直接退出循环、continue仅退出当前，不执行后面的程序，重新循环
- 函数
def 函数名（形参）：
def get_name(first_name,middle_name,last_name=’’):#last_name如果没有参数输入就输出空白
"""返回整洁的姓名"""
full_name = f"{first_name} {middle_name} {last_name}"
return full_name.title()
musician = get_name('john','lee','hooker') #两个等效，使用关键字调用的话，不用考虑参数顺序。
#musician = get_name(first_name = ‘john’,middle_name = ‘lee’,last_name = ‘hooker’)
print(musician)
返回值：
-
- 将函数存储在模块中
|
包含函数make_pizza()的模块，模块是扩展名为,py的文件 def make_pizza (ansel, *loo): print(f"Hello, my name is {self.name}") import pizza pizza.make_pizza(16,’peppereoni’) |
扩展名是.py的模块
import的用法：（）
基本用法：在Python中，import语句用于导入模块，这样你就可以使用其他模块中定义的函数、类或变量。import语句的基本语法是import module_name。你可以通过module_name.function_name()的方式来调用函数。module_name为模块名
导入特定功能：如果你只需要模块中的某个特定功能，可以使用from module_name import function_name的语法，直接导入所需函数到当前命名空间。function_name为指定函数
导入模块中的所有函数：from pizza import * #使用星号可导入模块中的所有函数。
使用as关键字：为了避免命名冲突或长模块名的引用，可以在import语句中使用as关键字为模块设置别名，例如给模块：import numpy as np；给函数：from numpy import function_name as fn
def make_pizza(*topping) #其中星号为创建为topping的空元组，与将列表作为实参类似
def build_pp(first, last, **user_info) #两个星号为创建名为user_info的空字典。
def describe_pet(pet_name, animal_type=”dog”) #其中形参anmial_type指定了默认值“dog”，调用函数时，如果没有给anmial_type指定值，这个形参默认为为”dog”，=两边不要有空格。
#os.path.join是Python中的一个函数，用于将多个路径组件合并成一个路径。
%的用法：（百分号）
|
import os path = os.path.join('d', 'python312', 'workspace') print(path) name = "张三" age = 25 message = "我的名字是%s，我今年%d岁。" % (name, age) print(message) # 输出结果为 "我的名字是张三，我今年25岁。" |
作为取余运算符；作为字符串格式化操作符：用于将变量插入到字符串中
打印函数，如果没有返回值，则会输出none，
print(make.pizza())
- 类 car
|
class Parent: def __init__(self, name): self.name = name def greet(self): print(f"Hello, my name is {self.name}") class Child(Parent): def __init__(self, name, age): super().__init__(name) # 调用父类的__init__方法 self.age = age def greet(self): super().greet() # 调用父类的greet方法 print(f"I am {self.age} years old") # 创建一个Child对象 child = Child("Alice", 10) child.greet() |
python中，类的首字母大写，类中的函数称为方法，__init__()是一个特殊方法，（int两侧各有两个下划线），python会自动运行。当你定义一个类的方法时，第一个参数通常是self，每个与实例相关联的方法调用都自动传递实参self，它是一个指向实例本身的引用，让实例能够访问类中的属性和方法。self会自动传递，因此不需要传递它。
访问属性：变量前缀都有self，以self为前缀的变量可供类中的所有方法使用。self.name = name获取与 形参name相关联的值，并将其值赋给变量name，该变量会被关联到当前创建的实例。
my_new_car = Car('audi','A4',2019)
print(my_new_car.get_descriptive_name())
#my_new_car.odometer_reading = 23 #直接修改属性的值。
my_new_car.update_odometer(23) #通过方法来修改属性的值。
my_new_car.read_odometer()
#my_new_car.update_odometer(10) #禁止往回调里程数
my_new_car.increment_odometer(56)
my_new_car.read_odometer()#函数increment()累加里程数
-
- 继承
在既有类的基础上编写新的类，通常需要调用父类的__init()__，可初始化在父类__init()__中的定义的所有属性，同时，还可定义自己的属性。
super()函数用于调用父类（超类）的方法。它常用于子类中，以便在子类方法中访问和使用父类的方法和属性。这在多重继承的情况下尤其有用，因为它可以避免硬编码父类的名称，从而减少错误并提高代码的可维护性。
使用super().__init__(name)来调用Parent类的__init__方法，以确保父类的初始化逻辑得到执行。同样，在Child类的greet方法中，我们使用super().greet()来调用Parent类的greet方法，然后添加额外的输出以显示子类特有的信息。
子类中重写父类中的方法，在子类中重新定于一个相同的方法名，运行时只会考虑子类的方法。
-
- 导入类
car.py文件，包含类Car，导入：from car import Car #打开模块car并导入其中的Car类。
注意：导入car.py文件时，首先执行car.py文件，若其中有输出，则会首先显示文件car.py的输出。
一个模块可储存多个类，可从一个模块中导入多个类，也可导入整个模块，
使用别名：from electric_car import ElectricCar as EC，给ElectricCar指定一个别名EC。
标准库：模块random，randint()随机返回一个两个整数之间的整数，
-
文件with open('pi_digits.txt') as file_object: contents = file_object.read()
print(contents)
filename = 'pi_digits.txt'
with open(filename) as file_object:
for line in file_object:
print(line)
contents = file_object.read()
print(contents)contents为一个字符串
filename = 'pi_digits.txt'
with open(filename) as file_object:
lines = file_object.readlines()
print(lines)输出：（lines为一个列表）
['3.141526535\n', ' 879323846\n', ' 264338327\n']
open()函数，只有先打开文件，才能访问它file_reader所在目录查找pi_digits.txt，函数open()返回一个表示文件的对象，python将pi_digits.txt赋给file_object使用，关键字with在不需访问文件后将其关闭，也可以调用close()将其关闭，使用方法read()读取这个文件的全部内容。
若文件与程序在同一个文件夹内，直接open(‘file_name’)，若在下级目录中，可open(‘text_files/file_name’)，也称绝对文件路径with open('d:/pycharm/pythonfile/file_10/text_files/pi_digits.txt') as file_object:
输出结果会多返回一个空行，read()到达文件末尾时会返回一个空字符串。可用rstrip()。
|
filename = 'pi_digits.txt' while True: |
右侧程序for循环为逐行遍历，到contents这一行它将返回一个空字符串，因为文件指针已经在文件末尾了。程序输出每行之间多了一个空白行，是因为pi_digits.txt模块每行末尾有一个换行符，而函数调用print()也会加上一个换行符。
read()读取文件的全部内容，readlines()读取文件的每一行，每个字符串后均有一个换行符。
变量pi_string指向的字符串包含原来位于每行左边的空格，时使用strip()来删除两端的空格。
pi_string存储文件pi_digits.txt中所有的元素，输出取前52位。
find()函数，定位作用
try-except组合可进行试错，
写入文件：若要将文本写入文件，需调用open()时提供另一个实参，如：
with open('programming.txt','w') as file_objects:
file_objects.write("I love programming!")
调用open()函数时提供了两个实参，第一个实参是要打开的文件，第二个实参（‘w’），要以写入模式打开这个文件，打开文件时可指定读取模式r、写入模式w、附加模式a或读写模式a+。如果省略了模式实参，将会默认为只读模式打开文件。写入模式当找不到文件时，会创建对应的文件。
-
- 异常
使用一场避免崩溃，发生错误时，如果还有工作尚未完成，需妥善处理，常出现在要求用户输入的程序中，与上述一致。
处理FileNotFoundError异常，
分析文本：title
|
filename = 'alice.txt' |
#split()以空格为分隔符将字符串拆分多个部分，并将这些部分都存储到一个列表中
UTF-8是一种变长的编码格式，它可以用来表示Unicode字符集中的任何字符。一种模式实参。
f.read()时，并且不提供任何参数，它会返回文件的所有内容，作为一个字符串。这种方法适用于文件较小，可以一次性加载到内存中的情况。
# anwser = int(first_number) / int(second_number)
# print("{:.9f}".format(anwser)) #使用round()函数，保留两位小数
# anwser = round(anwser, 2) #使用格式化字符串，保留两位小数
# print(anwser)
read()：该方法读取文件的全部内容，返回一个字符串。如果文件非常大，加载到内存中可能会导致性能问题。
readlines()：此方法读取文件的每一行，将其作为字符串列表返回。每个列表项代表文件中的一行，保留行尾的换行符。
pass：发生异常时，跳过，没有输出。
存储数据：模块json能够将python数据储存到文件中，在程序再次运行时加载该文件，json是一种数据格式。使用dump()将数字列表存储到文件中，使用load()加载.json中的信息。
dump(a,b)表示将对象a编码为json格式写入b。
- 模块
struct模块是Python的一个内置模块，用于处理二进制数据。它提供了一些函数来将Python数据类型（如整数、浮点数、字符串等）转换为字节串（即二进制数据），以及将这些字节串转换回原始的Python数据类型。这对于处理网络通信、文件读写或与其他语言进行数据交换时非常有用。
字节序（Byte Order）是指多字节数据在内存中的存储顺序。它决定了一个整数或浮点数的高位字节和低位字节的顺序。字节是最小的可寻址单位，通常由8个二进制位组成。有两种主要的字节序：
大端字节序（Big-Endian）：高位放在低地址里面，低位放在高地址里面，12是高位，开头是低地址，所以12在最前面。高位字节在前，低位字节在后。例如，整数0x12345678在大端字节序中存储为12 34 56 78。0x等效8个二进制位为两位十六进制，因此是12。
小端字节序（Little-Endian）：低位字节在前，高位字节在后。例如，整数0x12345678在小端字节序中存储为78 56 34 12。
import os #os模块是Python的一个内置模块，提供了与操作系统交互的功能。通过导入os模块，你可以使用它来执行各种操作系统相关的任务，如文件和目录操作、环境变量管理等。
import struct #用于处理二进制数据
import numpy as np #给模块numpy指定别名np ，numpy是一个用于Python编程语言的库，支持大量的维度数组与矩阵运算，此外也针对数组运算提供大量的数学函数库。NumPy在数据分析、机器学习等领域有着广泛的应用
import matplotlib.pyplot as plt # Matplotlib.pyplot是一个Python绘图库，它提供了类似于MATLAB的绘图接口。通过使用Matplotlib.pyplot，你可以创建各种类型的图表，如折线图、散点图、柱状图等。Matplotlib.pyplot是Matplotlib的一个子模块，通常与NumPy一起使用，以方便地处理和显示数据。
def load_mnist(path, kind="train"): #默认为train，
#读写文件用，这里的文件应该是已经解压完的文件
labels_path = os.path.join(path, '%s-labels.idx1-ubyte' %kind)
# %s 是一个占位符,可以将变量 kind 的值插入到字符串中，替换掉 %s
images_path = os.path.join(path, '%s-images.idx1-ubyte' %kind) #代码的目的是生成一个新的文件路径
with open(labels_path, 'rb') as lbpath:
magic, num = struct.unpack('>II'，lbpath.read(8)) #I表示一个无符号整数，4个字节，32位，>表示大端顺序
labels = np
sys模块：用于与Python解释器进行交互和控制程序的运行环境。
- pygame
安装pygame，终端中执行python -m pip install pygame
开始创建游戏，创建pygame窗口及应用用户输入，pygame.init() 是一个用于初始化 Pygame 库的函数。
设置背景色：
-
- 肢解alien程序：
第一步：
import sys #导入模块sys
import pygame
class AlienInvasion:
def __init__(self): 定义方法
pygame.init() #初始化背景设置
self.screen = pygame.display.set_mode((1200,800)) #调用pygame.display.set_mode()来创建一个窗口。
pygame.display.set_caption("Alien Invasion") #设置该窗口的标题文本
def run_game(self): #游戏的主程序
while True: #主程序持续循环
for event in pygame.event.get(): #监视事件的发生，鼠标或键盘都会导致事件的发生
if event.type == pygame.QUIT:
sys.exit()
pygame.display.flip() #让最近绘制的屏幕可见，while的每一次循环都会擦去旧屏幕并绘制新的屏幕
if __name__ == '__main__': #检查当前脚本是否作为主程序运行
ai = AlienInvasion() #创建一个AlienInvasion()的实例
ai.run_game() #运行ai中的run_game()
第二步：
self.bg_color = (230,230,230) #生成一个颜色赋给self. bg_color
主程序中：
self.screen.fill(self.settings.bg_color) #调用pygame.display.set_mode((1200,800))中的方法fill()用以填充屏幕背景色
第三步：
设置模块，创建类Settings，将所有的设置存储在一个模块，每次访问设置时，只需使用一个设置对象，更改游戏的参数和行为更为容易。
class Settings:
def __init__(self):
self.screen_width = 1200
self.screen_heigh = 800
self.bg_color = (65,179,73) #http://zhongguose.com/,配色方案
存储参数，并在主程序中调用类，
第四步：
创建ship类，负责处理飞船的图像，
self.ship = Ship(self) #括号中有self是为了在Ship中能使用当前对象的属性或方法，调用Ship时，必须提供一个参数：一个AlienTnvasion。这里的self指向的是当前的AlienTnvasion，这个参数让Ship能够访问游戏资源，如对象screen，将Ship这个实例赋给了self.screen。
bullet.draw_bullet()
Python中的事件都是通过pygame.event.get()来获取的，因此需要检查哪些类型的事件，
方法的重构使得程序更具有可读性，
如果 event.type 是 pygame.KEYDOWN 或 pygame.KEYUP，那么 event.key 属性就会包含被按下或者释放的键的pygame.key.*常量。
self.ship.rect.x 表示飞船对象的矩形边界框的 x 坐标
按键配置，
elif event.type == pygame.KEYDOWM:
if event.key == pygame.K_RIGHT
检测事件是否为键盘，是否为右键。
允许持续移动，结合KEYDOWN和KEYUP事件及一个名为moving_right的标志来实现持续移动
学到这里突然不想学了，直接啃程序！但是呢上面的不学程序肯定是啃不下来的。
扫一扫
4948
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
