python学习笔记1

变量

变量名由字符、数字、下划线组成。用下划线分隔变量名。

python数据类型

• 字符串，单引号或双引号括起来。title()方法，把首字母变大写；upper()、lower()方法。
• 数字，包括整数和浮点数。数字和字符串不能直接用+号连接，需要使用str()函数转换成字符串。3 ** 2 表示3的平方。

列表

## 定义一个列表
persons = ["zhangsan","lisi"]
print(persons)

# 取值
person = persons[0], # 索引为-1时标识取最后一个元素，以此类推，-2表示倒数第二个元素

# 插入元素
persons.append("wangwu") # 在列表末尾添加元素
persons.insert(0, "ergou") # 在列表的任意位置插入元素，需要指定插入的索引位置，这种操作会使列表中的所有元素后移一位

# 删除元素
del persons[0] # 使用del语句删除列表中的任意元素
persons.pop()  # 弹出列表的最后一个元素并返回这个元素
persons.pop(0)  # 弹出列表的第一个元素并返回这个元素
persons.remove("zhangsan") # 根据值删除元素，只删除第一个指定值的元素

# 排序
persons.sort() # 按字母顺序正序排序
persons.sort(reverse=True) # 按字母顺序倒序排序
print(sorted(persons))  # 使用sorted()函数临时排序，不影响原列表
persons.reverse()  # 反转列表元素的排列顺序

# 获取列表的长度
len(persons) # 使用len()函数获取列表长度

# 遍历整个列表
# Python根据缩进来判断当前代码行与前一代码行的关系，对于for循环，后面跟随着缩进的语句都属于for循环的循环体。
for person in persons:
    print(person)

# 创建数值列表
for value in range(1,5)
	print(value)  # 打印1，2，3，4
numbers = list(range(1,5))	# 生成一个列表

# 对数值列表计算
min(numbers)
max(numbers)
sum(numbers)

# 列表解析，将for循环和创建新元素的代码合并成一行，并自动附加新元素。
numbers = [value ** 2 for value in range(1,5)] # 生成一个包含1-4的平方的列表

# 切片
persons[0:4] # 获取第1-4个元素
persons[:4]  # 获取第1-4个元素
persons[0:]  # 获取第一个元素到最后
persons[-3:] # 获取倒数第三个到最后的元素

# 复制列表
persons_1 = persons[:]

元组

列表用于存储可变的数据集，元组用于存放不可修改的元素。元组就是不可变的列表。
元组使用圆括号标识。

# 定义元组，定义之后元组的内容不能修改
persons = ("zhangsan","lisi")

if语句

# if语句的例子
num = 1
if num == 1:
	print("哈哈哈")
elif num > 2 and num < 3:
	print("嘿嘿")
elif num == 4 or num ==5:
	print("呵呵呵")
else：
	print("啪啪啪啪")
	

# 检查特定值是否包含在列表中，使用in关键字和not in关键字
persons = ["lisi"]
if "lisi" in persons:
	print("ok")
elif "lisi" not in persons:
	print("no")

# 检查列表是否是空列表,列表变量名用做条件表达式中时，列表为空时返回True,否则返回False
if persons:
	print("ok")
else:
	print("no")

字典

# 包含简单信息的字典
person = {'name': 'zhangsan', 'age': 18}

# 使用字典
name = person['name']  # 获取key为name的值
person['address'] = '北京'  # 添加键值对
del person['address'] # del语句删除键值对


# 遍历字典所有键值对
for k,v in person.items():  # items()方法返回一个键值对列表, k,v可以是任何名称
	print(k)
	print(v)
# 遍历字典的键
for k in person.keys():
	print(k)

# 遍历字典中的所有值
for v person.values():
	print(v)
# 字典的值列表可能有重复的值，可以使用set()函数找出列表中不重复的元素并组成新的列表
for v set(person.values())
	print(v)
# 字典中存字典，字典中存储列表， 列表中存储字典

获取用户输入

# input函数接收一个参数用于提示用户输入什么，返回用户输入的内容，
name = input('what is your name')
print(name)

# input()函数的返回值是字符串，如果要把字符串转换成数值，使用int()函数
age = input('how old are you')
age = int(age) # 把字符串转换成整数
if age > 18:
	print('ok')

while循环

persons = ['zhangsan', 'lisi']
while person:
	person = persons.pop()
	if person == 'zhangsan':
		break  # 终止循环
	else:
		continue # 退出本次循环

# 删除列表中存在的多个同样元素
while 'zhangsan' in persons:
	persons.remove('zhangsan')

函数

# 定义一个函数
def function_name():
	"""函数功能描述"""  # 这个是文档字符串，用于生成函数的文档
	print("hello")

# 传递参数有三种方式，位置实参，关键字实参，默认值
def f1(param1, param2='dog'):  # param2参数设置了默认值dog,设置了默认值的参数必须放在最后，调用时可以不传此参数，=号两边不要有空格，传递实参的时候也不要有空格
	print(param1 + param2)
f1('abc')  # 调用f1,不传param2
f1('abc', 'cat') # 调用f1,传param2覆盖默认值，这种方式使用的是位置实参
f1(param2='cat',param1='abc') # 关键字实参

# 接收任意数量的参数,调用函数时*号会让Python把实参列表转换成一个元组
def f2(param1, *names):
	print(param1)
	for name in names:
		print(name)
f2('param1','zhangsan','lisi') # param1的值会被赋值到param1上，剩下的参数会被存储到元组names里。

# 接收任意数量的关键字实参， **会让Python创建一个空字典，把接收到的键值对存储到这个字典里
# 编写函数时，可以以各种方式混合使用位置实参、关键字实参和任意数量的实参

def build_profile(first_name, last_name, **user_info):
	***创建一个字典，其中包含用户的一切信息***
	profile = {}
	profile['first_name'] = first_name
	profile['last_name'] = last_name
	for k,v in user_info.items():
		profile[k] = v
	return profile

# 将函数存储在被称为模块的文件中，文件名就是模块名，import语句允许在当前文件中使用模块中的代码
# 模块是扩展名为.py的文件，先创建包含make_pizza()函数的模块,pizza.py
def make_pizzy():
	print('ok')
# 在另外一个文件中调用模块
import pizza
	pizza.make_pizza()

# 导入特定的函数
from pizza import make_pizza

# 使用as给函数命名
from pizza import make_pizza as mp

# 使用as给模块名命名
import pizza as p

# 导入模块中的所有函数
from pizza import *

# 建议使用导入模块名的方式，使用的时候通过module_name.function_name()的方式调用，或者只导入需要的函数。

# 函数返回值,函数可以返回任何类型的值，包括列表或字典等较复杂的数据结构
def f1():
	return 'hello'

def f2():
	return {'first':'wang', 'last':'shuzhou'}

函数编写指南

类

创建类

# 类名的首字母要大写，并且使用驼峰命名法
class Dog():
	# 类的文档字符串
	"""这是一个抽象小狗的类"""
	
	# 类中的函数称为方法，__init__()是一个约定的方法，实例化类时会自动运行这个方法
	# self参数必不可少，并且必须是方法的第一个参数，调用类的每个方法时都会自动传入self, 我们不用传它，self实参代表实例本身
	# 类中的变量叫属性， 类中的每个属性必须有初始值
	def __init__(self, name, age):
		"""初始化属性name和age"""
		self.name = name
		self.age = age
	
	def sit(self):
		"""模拟小狗蹲下"""
		print(self.name.title() + " is now sitting")

my_dog = Dog('小黄', 6)
print("my dog name is " + my_dog.name.title()) # 访问实例属性
my_dog.sit() # 调用实例方法

使用类和实例

car.py

class Car():
	"""模拟汽车的类"""
	
	def __init__(self, year， model='bmw2.0'):
		"""初始化方法"""
		self.year = year
		self.model = model
	
	def get_desc():
		print(str(year) + ' ' + model)

my_car = Car(2021)
print(my_car.get_desc())
	

# 修改类的属性，有两种方式：直接修改属性值；通过方法修改属性值；
my_car.year = 2022  # 直接修改属性值

def update_year(self, year): # 在Car类中添加update_year()方法修改year属性
	self.year = year

继承

一个类继承另一个类时，它会自动获得另一个类的属性和方法，原有的类称为父类，而新类称为子类。子类也可以定义自己的属性和方法。

创建子类的实例时，Python首先要给父类的属性赋值，因此，子类的__init__()方法需要调用父类的__init__()方法。

car.py
## 创建Car类的子类ElectricCar类, Car类必须和ElectircCar在同一个文件或者导入Car类到当前文件中，并且Car必须定义在ElectricCar类之前。
class ElectricCar(Car):
	"""电动汽车类"""
	
	def __init__(self, year, model):
		"""初始化父类的属性"""
		super().__init__(year, model)
	
	# 重写父类方法
	def get_desc():
		print(str(year) + '-' + model)


my_car = ElectricCar(2021, 'bmw2.0')

导入类

# 导入单个类
from car import Car # 导入单个类
my_car = Car(2021, 'bmw2.0')

from car import Car,ElectricCar # 导入多个类
my_car = Car(2021, 'bmw2.0')

import car # 导入整个模块
my_car = car.Car(2021, 'bmw2.0')

from car import * # 导入模块中的所有类，不推荐这种用法

Python标准库

类编码风格

文件

读取文件

# with语句帮助我们在合适的时候关闭文件；否则就要手动单独的调用文件对象的close()方法。
# open()函数接收文件的路径，返回文件对象存储在as后面指定的变量上
# 文件的路径可以是相对路径，也可以是绝对路径。如aaa.text、bbbFolder/bbb.text是相对路径，相对于当前文件的文件夹，如/user/lufei/ccc.text是绝对路径。
# linux和macox系统文件路径分隔符是/ windows系统是\
with open('aaa.text') as file_object:
	contents = file_object.read()
	print(contents.rstrip()) # read()方法读到文件末尾时返回一个空字符串，这个空字符串显示出来就是一个空白行，所以要去掉

# 逐行读取文件
with open('aaa.text') as file_object:
	for line in file_object:
		print(line.rstrip()) # 每行的末尾都有一个换行符，而print语句也会打印一个换行符，所以要消除一个换行符

# 创建一个包含文件各行的列表
with open('aaa.text') as file_object:
	lines = file_object.readlines() # 返回一个包含各行的列表

for line in lines:      # 在with代码块外，依然可以使用lines变量
	print(line.rstrip())

# 读取文本文件时，Python将其中所有的文本都解读为字符串，如果读取的是数字，需要使用int()函数或者float()函数将其转换为数字

写入文件

open()函数打开文件时，可指定四个模式，分别为读取模式®, 写入模式(w)，附加模式(a)，读写模式(r+)，如果省略了模式实参，默认模式为读取模式。

# 如果打开的文件不存在，open()函数将会创建一个新文件，如果存在会清空文件，open()函数然后再返回文件对象
with open('aaa.text', 'w') as file_object:
	file_object.write('i love you')
	file_object.wirte(str(5)) # python只能将字符串写入文件

存储数据

模块json能够把简单的python数据结构存储到文件中。

import json
numbers = [1,2,3,4,5]

file_name = 'numbers.json'
with open(file_name, 'w') as file_object:
	json.dump(numbers, file_object)  # 存储数据

with open(file_name) as file_object:
	numbers = json.load(file_object)  # 读取数据

print(numbers)

异常

first_number = input('please input first number')
second_number = input('please input second number')
try:
	answer = first_number/second_number # 可能出现异常
except ZeroDivisionError:
	pass # pass语句明确告诉程序出现异常什么也不做
	# print('you can not divide by 0')
else:
	print(answer) # else代码块不是必须的

测试

python标准库中的模块unittest提供了测试工具，
单元测试类首先要导入unittest模块，以及要测试的函数或者类，并且测试类要继承unittest.TestCase类，测试类的名称中要含有Test字样并且测试方法的方法名要以test开头，这样Python才会自动运行这个类中的测试方法。

import unittest
from test_function import hello_world # 导入要测试的函数
from test_class import Car  # 导入要测试的类

class NamesTestCase(unittest.TestCase):
	"""单元测试"""
	def setUp(self): # setUp函数会在所有测试执行前自动执行，用于初始化公共的实例和属性
		my_car = Car() 
	
	def test_hello_world(self):
		self.assertEqual(hello_world(), 'hello world') # 断言方法

	def test_car(self):
		my_car.move()  # 可以使用setUp()方法中初始化的my_car
	
unittest.main() # 运行测试类中的所有测试方法

常用的断言方法

测试结果