文章目录
第二章 变量和简单的数据类型
命名变量,要避免与关键字重复。
import keyword
print(keyword.kwlist)
['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
1.删除空白
name = "abc ecDAS "
print(name)
print(name.rstrip())
要确保字符串后面没有空白,可以使用rstrip()。但是这个删除是暂时的,不会影响到变量本身。
同时也可以剔除字符串两端或者开头的空白,分别使用strip()和lstrip()。
2.在python中输出双引号或者单引号的四种解决方案
(1)使用转义字符
print( "\"abc\"")
输出如下
"abc"
(2)单双引号交叉使用
字符串本身含有单引号,那么字符串两端就用双引号来标记,反之亦然
(3)三引号
虽然三引号被用来定义多行文本,但是同样可以用来定义单行文本,当使用三引号标记字符串时,那么字符串本身的单引号和双引号都能正常显示
3.使用str()函数避免类型错误
age = 22
mes = "happy " + str(age) + "rd birthday"
print(mes)
结果:
happy 22rd birthday
第三章 列表简介
3.1 列表是什么
在Python中,用方括号([])来表示列表,并用逗号来分隔其中的元素。
3.2 修改、添加、删除元素
1.在列表末尾添加元素
a = [2,5,4,7]
a.append(8)
print(a)
结果:
[2, 5, 4, 7, 8]
方法 append () 将元素8添加到了列表末尾。
2.在列表中插入元素
a = [2,5,4,7]
a.insert(0,1)
print(a)
结果:
[1, 2, 5, 4, 7]
方法insert()将元素插入到指定位置。
3.从列表中删除元素
(1)使用del删除元素
a = [0,1,2,3,4]
del a[0]
print(a)
结果:
[1, 2, 3, 4]
del可以删除指定位置的元素
(2)使用pop删除元素
a = [0,1,2,3,4]
b = a.pop(2)
print(a)
print(b)
结果:
[0, 1, 3, 4]
2
pop()删除指定位置的元素,并且可以使用该元素,pop()默认弹出的位置是列表末端的元素。
(3)根据元素值删除元素
a = [0,1,2,3,4,4]
a.remove(4)
print(a)
结果:
[0, 1, 2, 3, 4]
remove只能删除第一个为该值的元素,若多次出现,需要结合循环使用。
3.3 组织列表
1.使用sort()对列表进行永久性排序
a = [2,5,4,2,4,8,9,1,0,7,5]
a.sort()
print(a)
结果:
[0, 1, 2, 2, 4, 4, 5, 5, 7, 8, 9]
也可以进行反向排序,此时sort(reverse = True)。
a = [2,5,4,2,4,8,9,1,0,7,5]
a.sort(reverse = True)
print(a)
结果:
[9, 8, 7, 5, 5, 4, 4, 2, 2, 1, 0]
2.使用sorted()对列表进行临时性排序
该函数只是展示出来一定的顺序,并没有改变列表本身,跟删除空白的strip()是类似的,只是暂时。
a = [2,5,4,2,4,8,9,1,0,7,5]
print(sorted(a))
print(a)
结果:
[0, 1, 2, 2, 4, 4, 5, 5, 7, 8, 9]
[2, 5, 4, 2, 4, 8, 9, 1, 0, 7, 5]
3.倒着打印列表
将该列表颠倒顺序。
a = [0,1,2,3,4]
a.reverse()
print(a)
结果:
[4, 3, 2, 1, 0]
4.确定列表长度
使用len()函数。
第四章 操作列表
1.遍历整个列表
a = [0,1,2,3,4]
for b in a:
print(b)
结果:
0
1
2
3
4
2.创建数值列表
(1)使用range()函数
a = [0,1,2,3,4]
for b in range(0,5,2):
print(b,end="")
结果:
024
(2)使用range()创造数字列表
b = list(range(0,5))
print(b,end="")
结果:
[0, 1, 2, 3, 4]
(3)列表解析
squares = [value**2 for value in range(0,5)]
print(squares)
结果:
[0, 1, 4, 9, 16]
复制列表进行操作:
a = list(range(0,11))
b = a[:]
c = a
a.append(11)
b.append(12)
c.append(13)
print(a)
print(b)
print(c)
结果:
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13]
其中,b = a[:]才是复制,c = a只是两个变量关联起来。
3.元组
元组是不可以修改的,用圆括号表示,而可修改的列表是方括号。
第五章 if语句
1.检查特定值是否在列表中
使用关键词in。
cars = ['bmw','audi','toyota','subaru']
car = 'bmw'
if car in cars:
print(car.upper())
else:
print(car.title())
结果:
BMW
2.if语句
(1)简单if语句
(2)if-else语句
(3)if-elif-else语句
(4)使用多个elif语句
(5)省略else语句块:有时候最后使用else很有用,能够节省条件满足的显示,但是有时候elif会让条件更加的清晰。
(6)测试多个条件
第六章 字典
1.使用字典
字典是一系列键-值对,每个键都与一个值相关联,可以使用键来访问相关联的值,这个值可以是各种格式。
字典用放在花括号{}中的一系列键值对表示。
car_0 = {'color':'blue','brand':'subaru'}
print(car_0['color'])
print(car_0['brand'])
结果:
blue
subaru
(1)添加,改变键-值对
字典是一种动态结构,可随时在其中添加键-值对。要添加键-值对,可依次指定字典名、用方括号括起的键和相关联的值。
car_0 = {'color':'blue','brand':'subaru'}
car_0['type'] = 'STI'
print(car_0)
结果:
{'color': 'blue', 'brand': 'subaru', 'type': 'STI'}
这个方法依然可以用来修改键-值对
(2)删除一对键-值对
使用del语句。
car_0 = {'color':'blue','brand':'subaru'}
car_0['type'] = 'STI'
print(car_0)
del car_0['type']
print(car_0)
结果:
{'color': 'blue', 'brand': 'subaru', 'type': 'STI'}
{'color': 'blue', 'brand': 'subaru'}
2.遍历字典
car_0 = {'color':'blue','brand':'subaru'}
car_0['type'] = 'STI'
for k,v in car_0.items():
print(k,v)
结果:
color blue
brand subaru
type STI
一定要注意这个items()。
同样的,若只想遍历键,将后缀改为keys(),若只想遍历值,将后缀改为values()。
可以按照排序顺序遍历:添加sorted()函数:
car_0 = {'color':'blue','brand':'subaru'}
car_0['type'] = 'STI'
for k in sorted(car_0.keys()):
print(k)
结果:
color
brand
type
3.嵌套
可以在列表中嵌套字典,也可以在字典中嵌套列表,也可以字典嵌套字典。
第七章 用户输入和while循环
1.input()函数
message = input("输入名字:")
print("你好," + message + "!")
结果:
输入名字:水熊
你好,水熊!
但是在使用input()函数时,python将用户输入解读为字符串。
所以可以使用int()函数来将数字的字符串表示转化为数值,有点类似str()函数,都是格式的转换。
2.while循环
(1)使用标志
(2)使用break跳出循环
break是不执行余下代码,直接跳出循环。
(3)使用continue
continue是让python忽略下列的代码,回到循环的开头。
num = 1
while num < 10:
num += 1
if num %2 == 0:
continue
print(num)
结果:
3
5
7
9
(4)填充字典
cars = {}
flag = True
while flag:
name = input("please enter your name:")
car = input("please enter your favirate car:")
cars[name] = car
repeat = input("would want to repeat(y/n):")
if repeat == 'n':
flag = False
print(cars)
for k,v in cars.items():
print(k + " like "+v)
输入:
please enter your name:jack
please enter your favirate car:subaru
would want to repeat(y/n):y
please enter your name:tom
please enter your favirate car:tayota
would want to repeat(y/n):y
please enter your name:lisa
please enter your favirate car:honda
would want to repeat(y/n):n
结果:
{'jack': 'subaru', 'tom': 'tayota', 'lisa': 'honda'}
jack like subaru
tom like tayota
lisa like honda
第八章 函数
1.传递参数
(1)位置实参
当调用函数时,Python必须将函数调用中的每个实参都关联到函数定义中的一个形参。为此,最简单的关联方式是基于实参的顺序。这种关联方式被称为位置实参。
(2)关键字实参
关键字实参是传递给函数的名称一值对。你直接在实参中将名称和值关联起来了,因此向函数传递实参时不会混淆。关键字实参让你无需考虑函数调用中的实参顺序,还清楚地指出了函数调用中各个值的用途。
(3)默认值
编写函数时,可给每个形参指定默认值。在调用函数中给形参提供了实参时,Pton将使用指定的实参值﹔否则,将使用形参的默认值。因此。给形参指定默认值后,可在函数调用中省略相应的实参。使用默认值可简化函数调用,还可清楚地指出函数的典型用法。
注意﹐使用默认值时,在形参列表中必须先列出没有默认值的形参,再列出有默认值的实参。这让Python依然能够正确地解读位置实参。
2.传递列表
可以在函数中修改传递给函数的列表,也可以传递给函数这个列表的副本,不改变原来的列表。
下面展示不修改的示例:
def print_modles(unprinted_modles,complete_modles):
while unprinted_modles:
current_modles = unprinted_modles.pop()
complete_modles.append(current_modles)
def show_completed_modles(complete_modles):
for complete_modle in complete_modles:
print(complete_modle)
unprinted_modles = ['subaru','tayota','bmw']
complete_modles = []
print_modles(unprinted_modles[:], complete_modles)
show_completed_modles(complete_modles)
print(unprinted_modles)
结果:
bmw
tayota
subaru
['subaru', 'tayota', 'bmw']
3.传递任意数量的实参
(1)* 元组
下面的函数只有一个形参*toppings ,但不管调用语句提供了多少实参,这个形参都将它们统统收入囊中:
def make_pizza(*toppings):
print(toppings)
make_pizza('pepperoni')
make_pizza('jack','rose','james')
形参名*toppings中的星号让Python创建一个名为toppings的空元组,并将收到的所有值都封装到这个元组中。函数体内的print语句通过生成输出来证明Python能够处理使用一个值调用函数的情形,也能处理使用三个值来调用函数的情形。它以类似的方式处理不同的调用,注意,Python将实参封装到一个元组中,即便函数只收到一个值也如此:
结果:
('pepperoni',)
('jack', 'rose', 'james')
如果要让函数接受不同类型的实参,必须在函数定义中将接纳任意数量实参的形参放在最后。Python先匹配位置实参和关键字实参,再将余下的实参都收集到最后一个形参中。
(2)** 字典
def buy_cars(name,number,**detailes):
consumer_info = { }
consumer_info['Name'] = name
consumer_info['Number'] = number
for key,value in detailes.items():
consumer_info[key] = value
print(detailes)
return consumer_info
consumer_info = buy_cars('jack', 21,
brand = 'subaru',
color = 'blue',
model = 'brz')
print(consumer_info)
结果:
{'brand': 'subaru', 'color': 'blue', 'model': 'brz'}
{'Name': 'jack', 'Number': 21, 'brand': 'subaru', 'color': 'blue', 'model': 'brz'}
4.将函数存在模块中
通过将函数存储在独立的文件中,可隐藏程序代码的细节,将重点放在程序的高层逻辑上。这还能让你在众多不同的程序中重用函数。将函数存储在独立文件中后,可与其他程序员共享这些文件而不是整个程序。知道如何导入函数还能让你使用其他程序员编写的函数库。
(1)通过import导入模块。
(2)也可以通过 form module_name import function_1,function_2,function_3导入模块中的特定函数。
(3)使用as给函数或者模块定别名, form module_name import function_name as fn
第九章 类
1.创建和使用类
class Car():
def __init__(self,owner,brand,type,color,year):
self.owner = owner
self.brand = brand
self.type = type
self.color = color
self.year = year
self.odometer = 0
def print_detailes(self):
detailes = self.owner + " buy a "
detailes += self.brand + "'s " + self.type
detailes += " in " + str(self.year)
detailes += "\n" + self.owner +"\'s car is " + self.color
print(detailes)
def print_odometer(self):
print(self.owner +"\'s car has " + str(self.odometer) +" miles on it")
def update_odometer(self,milage):
self.odometer = milage
my_car = Car('pirlo','subaru','STI','blue',2020)
my_car.print_detailes()
my_car.odometer = 23
my_car.print_odometer()
my_car.update_odometer(81)
my_car.print_odometer()
结果:
pirlo buy a subaru's STI in 2020
pirlo's car is blue
pirlo's car has 23 miles on it
pirlo's car has 81 miles on it
有两种方法来改变属性的值,一种是直接修改,第二种是通过方法来修改属性的值。
2.继承
class Electric_Car(Car):
def __init__(self, owner, brand, type, color, year):
super().__init__(owner, brand, type, color, year)
创建子类时,父类必须包含在当前文件中,且位于子类前面。我们定义了子类Electric_Car。定义子类时,必须在括号内指定父类的名称。方法__init__()接受创建car 实例所需的信息。
super()是一个特殊函数,帮助Pyron将父类和子类关联起来。这行代码让Python调用ElectricCar的父类的方法__init__(),让Electric_Car实例包含父类的所有属性。父类也称为超类(superclass),名称super因此而得名。
# -*- coding: utf-8 -*-
#!/usr/bin/python
class Car():
def __init__(self,owner,brand,type,color,year):
'''初始化描述汽车属性'''
self.owner = owner
self.brand = brand
self.type = type
self.color = color
self.year = year
self.odometer = 0
def print_detailes(self):
'''整洁地输出汽车的信息'''
detailes = self.owner + " buy a "
detailes += self.brand + "'s " + self.type
detailes += " in " + str(self.year)
detailes += "\n" + self.owner +"\'s car is " + self.color
print(detailes)
def print_odometer(self):
'''输出汽车的行驶里程'''
print(self.owner +"\'s car has " + str(self.odometer) +" miles on it")
def update_odometer(self,milage):
'''
将汽车的行驶里程设为定值
并且拒绝回调里程数
'''
if milage >= self.odometer:
self.odometer = milage
else:
print("你不能回调里程数!!!")
def increase_odometer(self,miles):
'''将里程表增加指定值'''
if miles >= 0:
self.odometer += miles
else:
print("你不能减少里程数!!!")
class Battery():
def __init__(self,battery_size = 70):
'''初始换电瓶属性'''
self.battery_size = battery_size
def print_battery_size(self):
'''输出电瓶的剩余电量'''
print("the car has a " + str(self.battery_size)+"-KWh battery")
class Electric_Car(Car):
def __init__(self, owner, brand, type, color, year):
'''初始化父类的属性,再初始化电动车自有的属性'''
super().__init__(owner, brand, type, color, year)
self.battery = Battery()
my_electric_car = Electric_Car('pirlo','tesla','Modle X','black',2020)
my_electric_car.print_detailes()
my_electric_car.battery.battery_size = 170
my_electric_car.battery.print_battery_size()
结果:
pirlo buy a tesla's Modle X in 2020
pirlo's car is black
the car has a 170-KWh battery
第十章 文件和异常
1.读文件
(1)读取整个文件
with open('pi.digits.txt') as file_object:
contents = file_object.read()
print(contents)
我们先来看看函数open ()。要以任何方式使用文件——哪怕仅仅是打印其内容,都得先打开文件,这样才能访问它。函数open ()接受一个参数。要打开的文件的名称。Python在当前执行的文件所在的目录中查找指定的文件
关键字with在不再需要访间文件后将其关闭。在这个程序中,注意到我们调用了open (),但没有调用close();你也可以调用open ()和close ()来打开和关闭文件,但这样做时,如果程序存在bug。导致close()语句未执行,文件将不会关闭。这看似微不足道,但未妥善地关闭文件可能会导致数据丢失或受损。如果在程序中过早地调用close (),你会发现需要使用文件时它已关闭(无法访问),这会导致更多的错误。并非在任何情况下都能轻松确定关闭文件的恰当时机,但通过使用前面所示的结构,可让Python去确定:你只管打开文件,并在需要时使用它,Python自会在合适的时候自动将其关闭。
有了表示pi_digist.txt的文件对象后,我们使用方法read()读取这个文件的全部内容,并将其作为一个长长的字符串存储在变量contents中。这样,通过打印contents的值,就可将这个文本文件的全部内容显示出来:
3.1415926
相比于原始文件,该输出唯一不同的地方是末尾多了一个空行。为何会多出这个空行呢﹖因为read ()到达文件末尾时返回一个空字符串,而将这个空字符串显示出来时就是个空行。要删除多出来的空行,可在print语句中使用rstrip ():
(2)文件路径
(1)相对路径
根据你组织文件的方式,有时可能要打开不在程序文件所属目录中的文件。例如,你可能将程序文件存储在了文件夹pyton_work中,而在文件夹python_work中,有一个名为text_fies的文件夹,用于存储程序文件操作的文本文件。虽然文件夹text_fies包含在文件夹pfthon_work中,但仅向open ()传递位于该文件夹中的文件的名称也不可行,因为Pyton只在文件夹python_work中查找,而不会在其子文件夹text_fifes中查找。要让Python打开不与程序文件位于同一个目录中的文件,需要提供文件路径,它让.Python到系统的特定位置去查找。
with open('text_files\filename.txt') as fileobject:
(2)绝对路径
with open('D:\Study\Python\Python_Study_Space\study_demo\filename.txt') as fileobject:
(3)逐行读取
with open('pi.digits.txt') as file_object:
for line in file_object:
print(line.rstrip())
结果:
3.1415926
23564568
(4)创建一个包含文件各行的列表
with open('pi.digits.txt') as file_object:
lines = file_object.readlines()
for line in lines:
print(line.rstrip())
结果:
3.1415926
23564568
使用关键字with时,open ()返回的文件对象只在with代码块内可用。如果要在with代码块外访问文件的内容,可在with代码块内将文件的各行存储在一个列表中,并在with代码块外使用该列表:你可以立即处理文件的各个部分,也可推迟到程序后面再处理。
2.写文件
要将文本写入文件,需要在调用open()函数时提供另外的参数,告诉python我们要写文件。
with open('pi.digits.txt','a') as file_object:
file_object.write('i love football')
3.异常
(1)使用try-except代码块
try:
print(5/0)
except ZeroDivisionError:
print('零不能作除数')
我们将导致错误的代码行print(5/0)放在了一个try代码块中。如果try代码块中的代码运行起来没有问题,Pyton将跳过except代码块;如果try代码块中的代码导致了错误,Python将查找这样的except 代码块,并运行其中的代码,即其中指定的错误与引发的错误相同。
在这个示例中,try代码块中的代码引发了zeroDivisionError异常,因此P)fron指出了该如何解决问题的except代码块,并运行其中的代码。这样,用户看到的是一条友好的错误消息,而不是traceback:
零不能作除数
(2)使用异常避免崩溃
print("Give me two numbers,I'll divide them.")
print("Enter 'q' to quit.")
while True:
first_number = input("\nPlease input first number:")
if first_number == 'q':
break
second_number = input("Please input second number:")
if first_number == 'q':
break
try:
print(int(first_number)/int(second_number))
except ZeroDivisionError:
print('零不能作除数')
(3)使用esle代码块
print("Give me two numbers,I'll divide them.")
print("Enter 'q' to quit.")
while True:
first_number = input("\nPlease input first number:")
if first_number == 'q':
break
second_number = input("Please input second number:")
if first_number == 'q':
break
try:
ans = int(first_number)/int(second_number)
except ZeroDivisionError:
print('零不能作除数')
else:
print(ans)
当try中的代码块可以执行时,不发生错误,就会执行else中的代码。
用书本中的话来说就是:依赖try代码块成功执行的代码都应该放到else代码块中。
(4)失败时一声不吭
except ZeroDivisionError:
pass
将except模块中的代码改为pass。
4.存储数据(Json数据格式)
json.dump()和json.load()
第十一章 测试代码
import unittest
from test_name import get_formatted_name
class NameTestCase(unittest.TestCase):
def test_fisrt_last_name(self):
formatted_name = get_formatted_name('eric','jia')
self.assertEqual(formatted_name,'Eric Jia')
unittest.main()
test_name.py
def get_formatted_name(first,last):
'''产生一个整洁的大写统一名字'''
full_name = first + ' ' + last
return full_name.title()