python sort 部分元素_如何从零开始五天学完python语法

变量和简单数据类型

变量名的命名遵循和c语言一样的规则。

python中字符串既可以是单引号也可以是双引号.

---

修改字符串的大小写

name=“ada lovelace”
print（name.title())

name.title（）中的句点让python对变量name执行方法title()的操作。每个方法后面都跟着一对圆括号。

方法title（）以首字母大写的方式显示每个单词，即将每个单词的首字母都改为大写。

name.upper()将字符串改为全部大写

name.lower()将字符串改为全部小写

first_name="ada"
last_name="lovedace"
full_name=f"{first_name} {last_name}"//注意空格这个是代码规范
print(full_name)

要在字符串中插入变量的值，可在前引号前加上字母f，再将要插入的变量放在花括号内。这样，当python显示字符串时，将每个变量都替换为其值。 这种字符串名为f字符串。f是format的简写。

print函数中如果单纯一个字符串 print（”saaddsad“）

print如果单纯只有变量print（m）

print中如果有变量和字符串组合在一起print（f”hello，{full_name}“）

print两个变量（列表，单纯变量）其中用逗号分隔就可以了print（a，b）

---

删除空白

方法.rstrip()删除末字符串尾空白

.lstrip()剔除字符串前的空白

.strip()消除字符串两边的空白

favorite_language=' python '
favorite_language.rstrip()-->' python'
favorite_language.lstrip()-->'python '
favorite_language.strip()-->'python'

正确使用单引号和是双引号，不能混淆字符串接触的位置在哪里。

**来表示乘方运算

python对浮点数的运算：

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

4/2=2.0

在其他任何运算中，如果一个操作数是整数，另一个操作数是浮点数，结果也总是浮点数。

1+2.0=3.0
2*3.0=6.0
3.0**2=9.0

可以用下划线将其中的数字分组

a=14_00000_0000_000

当然在输出这个数的时候，python会自动忽略下划线。

同时给多个变量赋值

x,y,z=5,6,8

python里面没有const限定符。

python里面的注释用#代替c语言中的//

python里面的多行注释利用一对三个引号'''或者"""里面可以写很多

---

列表python的新玩具

列表由一系列按特定顺序排列的元素组成。可以创建包含字母，数字，以及任何类型的元素。（相当于一个没有限制的数组）

在python中利用[]来表示列表，用逗号分隔其中的元素。如果让python将列表打印出来，python将打印列表的内部表示，包括方括号

bicycles=['trek','cannondale','redline','specialized']print(bicycles)

会输出['trek','cannondale','redline','specialized']

访问列表元素

列表是有序集合，因此要访问列表的任意元素，只需要将该元素的位置（索引）告诉python即可。要访问列表元素，可指出列表的名称，在指出元素的索引，并将后者放在方括号内。

bicycles=['trek','cannondale','redline','specialized']
print(bicycles[0])这样会输出trek
print(bicycles[0].title())这样会输出Trek

在python中，第一个列表元素的索引是0，而不是1。（类比c语言的数组）

python为访问最后一个列表元素提供了一种特殊语法。通过将索引指定为-1，可让python返回最后一个列表元素：

bicycles=['trek','cannondale','redline','specialized']
print(bicycles[-1])这样会输出'specialized'同样这等同于print(bicycles[3])

类比一下，-2就是倒数第二个元素，-3就是倒数第三个元素，-4就是倒数第四个元素。

同样，我们可以把列表和字符串结合在一起
bicycles=['trek','cannondale','redline','specialized']
massage=f"my first bicycle was a {bicycles[0].title()}."

至于修改列表中的元素，类比数列中修改元素的做法。

bicycles=['trek','cannondale','redline','specialized']
b[0]='motorcycles'
print(b[0])将会输出motorcycles

如果要在列表中添加新的元素，最简单的方式是将元素附加（append）到列表。给列表添加新元素时，它将添加到列表的末尾。

motorcycles=['trek','cannondale','redline','specialized']
motorcycles.append('ducati')
print(motorcycles[-1])将会输出ducati。

可以先创建一个空列表，在在其中创建新的元素

motorcycles=[]
motorcycles.append('honda')
motorcycles.append('yamaha')
motorcycles.append('suzuki')
print(motorcycles)最终输出的列表['honda','yamaha','suzuki']

在列表中插入元素

使用方法.insert()可在列表的任何位置添加新的元素，为此要制定新的索引和值。

motorcycles=['honda','yamaha','suzuki']
motorcycles.insert(0,'ducati')#表明在第0个元素的位置添加'ducati'这个元素
print(motorcycles)这样子会输出['ducati'，'honda','yamaha','suzuki']

使用del语句删除元素

motorcycles=['honda','yamaha','suzuki']
print(motorcycles)
del motorcycles[0]#删除了列表motorcycles的第一个元素
print(motorcycles)

使用方法pop（）删除元素

motorcycles=['honda','yamaha','suzuki']
print(motorcycles)
popped_motorcycles=motocycles.pop()#把列表最后一个元素弹出，并且把这个元素给popped_motorcycles
print(motorcycles)
print(popped_motorcycles)
输出会如下所示
['honda','yamaha']
suzuki

pop()可以进化为弹出任意一个位置的元素，只需要在（）中加上需要弹出元素的索引即可。

motorcycles=['honda','yamaha','suzuki']
print(motorcycles)
popped_motorcycles=motocycles.pop(1)#把列表第二个元素弹出，并且把这个元素给popped_motorcycles
print(motorcycles)
print(popped_motorcycles)
输出会如下所示
['honda','suzuki']
'yamaha'

如果你要从列表中删除一个元素，就用del元素。如果你要从列表清楚一个元素，并且还要继续使用他，就用pop方法。

根据值删除元素只用方法.remove()

motorcycles=['honda','yamaha','suzuki']
print(motorcycles)
motorcycles.remove('yamaha')#从motorcycles这个列表中删除'yamaha'这个值的元素
print(motorcycles)
输出会如下所示
['honda','yamaha','suzuki']
['honda','suzuki']

---

组织列表

使用方法sort（）对列表永久排序。必须是需要按照字母顺序来排序的时候才会单纯的用到sort（）函数

        如果数字就会按照数字大小由小到大排列，但是如果数字和字母混合就无法进行,sort进行排序
cars=['bmw','audi','toyota','sybaru']
cars.sort()
print(cars)
输出如下
['audi','bmw','toyota','sybaru']

如果需要按照字母的逆序排列的话，就需要用到.sort(reserve=True)必须大写。

如果大小写混合字符，其实即使按照ascii码进行排序，大写字母的ascii码值在小写字母前面。猜想.sort函数就是在转化为ascii码值之后进行（从小到大.sort（）或者从大到小.sort(reserve=True)）数值排序。

使用函数sorted（）对列表进行临时排序，同样也可以用.sort（reverse=True）。

cars=['bmw','audi','toyota','sybaru']
print(cars)
print(sorted(cars))
print(cars)
将会输出
['bmw', 'audi', 'toyota', 'sybaru']
['audi', 'bmw', 'sybaru', 'toyota']
['bmw', 'audi', 'toyota', 'sybaru']

可以使用.reverse（）将列表的顺序颠倒，反转排列顺序，可以多次使用负负得正。

cars=['bmw','audi','toyota','sybaru']
print(cars)
cars.reverse()
print(cars)
将会输出
['bmw', 'audi', 'toyota', 'sybaru']
['sybaru', 'toyota', 'audi', 'bmw']

可以使用len（）函数获悉列表长度

cars=['bmw','audi','toyota','subaru']
len(cars)#这个表达式的值是4可以做右值给变量赋值

遍历列表，但是这个a最好和这个列表有一定的联系

for a in b：#其中a是任意的一个变量，b是一个列表，这个语句的意思是每次循环把b中的一个变量和a联系在一起
print（a）#输出a这个变量的值

---

避免缩进错误。

python根据缩进来判断代码行的关系。如上例所示，缩进的代码行是for循环的一部分。

不必要的缩进：
massage=‘hello python world’
    print（message）
忘记缩进
magicians=['alice','david','carolina']
for magician in magicians
print(magician)
忘记缩进第二行for循环代码
magicians=['alice','david','carolina']
for magician in magicians
    print(magician)
print(magician.lower())
print(magician.upper())
print(magician.tittle())
遗漏了冒号也不行

python函数range（）让你能够轻松地生成一系列数。同样可以打印range（）中的一系列数

range函数从你指定的第一个数开始，到你指定的第二个数结尾，但是不会包含第二个数。

for value in range(1，5): print(value)
这样会输出
1
2
3
4

range（）函数实际上的返回值是一个可迭代对象，也就是可以用在for循环里面的对象

可以写如下语句
for i in range(1,100)
print(i)

而list是一个迭代器，它的作用是将range生成的可迭代对象转化为一个列表

可使用函数list（）将range（）的结果直接转换为列表。如果将range（）作为list（）的参数，输出将是一个数字列表。

numbers=list(range(1,6))
print(numbers)
结果如下：
[1,2,3,4,5]

函数range（）还可以指定步长。为此可以给这个函数指定第三个参数

numbers=list(range(2,11,2))
print(numbers)
结果如下
[2,4,6,8,10]
        如何让一个列表中包含一到十所有偶数的平方
numbers=list(range(2,11,2))
squares=[]
for value in numbers:
    square=value**2
    squares.append(square)
print(squares)
    也可以直接写作
squares.append(value**2)

对列表进行统计计算（最小，最大，求和）用min（），max（），sum（）函数。格式min（list）

列表解析

可以把上面的平方列表折合成一步运算

squares=[value**2 for value in range(1,11,2)]

列表解析格式元素经过的操作（value**2）一个for循环语句其中包含参数（value）还有某一个列表（range（1，11，2））

---

使用列表的一部分

（1）切片

创建切片需要指定第一个元素和最后一个元素的索引。与range（）函数一样，在达到第二个索引之前的元素停止，不包含第二个索引的元素。格式如下 列表名[第一个索引值：第二个索引值]（如果没有指定第一个索引默认从头开始，没有指定第二个索引默认到头为止）

如果你想要输出最后三名队员的名字可以players[-3：]

players=['charles','martina','michael','florence','eli']
print(players[0:3])
这将会输出前三个元素
['charles', 'martina', 'michael']
        遍历切片的操作
players=['charles','martina','michael','florence','eli']
for player in players:
    print(player.title())

(2)复制列表

复制列表的原理就是创建你一个包含整个列表的切片，方法是同时省略起始索引和终止索引（[：])

my_food=['pizza','falafel','carrot cake']
friends_food=my_food[:]
print(f"my favorite foods are:{my_food}n")
print(f"my friends' favorite foods are:{friends_food.pop()}")

不可变的列表——元组

元组看起来很像列表，但是用圆括号而不是中括号来表示且不能被改变。定义元组之后，就可以使用索引来访问其元素，就像访问列表元素一样。如果定义一个只包含一个元素的元组，也必须加上一个的逗号，因为元组实际上是用逗号标识的，括号只是让他看起来更加的清晰。

a=(1,3,5,8)
print(ad[2])#输出元组中的第三个元素即5
mt=（5，）#定义一个只含一个元素的元组注意它的，我们可以通过别的方式修改元组的值，也就是再次定义
a=（2，3，5，8）
print（a）#此时会输出2，3，5，8而不是之前元组的1，3，5，8
#遍历元组和遍历列表同理，不再详细介绍

---

python中的if语句

#一个示例
cars=['audi','bmw','toyota','subaru']
for car in cars:
    if car=='bmw':
        print(car.upper())
    else:
        print(car.lower())
        if语句的核心都是一个值为true或者false的表达式，这种表达式被称为条件测试；条件测试中的表达式是会区分大小写的。
cars=['audi','bmw','toyota','subaru']
if cars[2]=='Toyota'#返回值是false
if cars[2].lower()#返回值是true
#数值判断完全与c相同，还有就是！=也相同，但python使用and表示符合多个条件
if (cars[2]=="toyota") and (cars[3]=="Subaru")#返回值是false
#python使用or来充当或（||)
if (cars[2]=="toyota") and (cars[3]=="Subaru")#返回值是true
执行操作时，列表是否包含特定的值也可以直接用if语句判断，加一个in也可以是（not in）
if "toyota" in cars#返回值为true

if-else语句，else用来执行操作不通过时要执行的操作。

python有个新语句if-elif-else这个语句相当于c语言中级联if-else

按年龄段收费的项目
4岁以内不用钱（小屁孩）
4-18岁 25元
18-65岁 40元
65岁以上 20元
if age<4:
    price=0
elif age<18:
    price=25
elif age<65:
    price=40
else:
    price=20
如果只想执行一个代码块，就使用if-elif-else结构；如果要执行多个代码块，就是用一系列独立的if语句
        使用ifelse来确定列表是不是空的，直接用列表名当作测试表达式
requested_toppings=[]
if requested_toppings:
    .........          #requesred_toppings是一个列表名，此时它的返还值是false 
        定义两个列表进行比对
available_toppings=['mushrooms','olives','green peppers','pepperoni','pineapple','extra cheese']
#定义了一个列表，其中包含比萨店供应的配料。请注意，如果比萨店供应的配料是固定的，也可使用一个元组来存储它们
requested_toppings=['mushrooms','french fries','extra cheese']
#创建了一个列表，包含顾客点的配料。
for requested_topping in requested_toppings:
#遍历顾客点的配料列表，在这个循环中，对于顾客点的各种配料，都检查它是否包含在供应的配料的列表中。
    if requested_topping in available_toppings:
        print(f"adding {requested}.")
    else:
        print(f"sorry,we don't have {requested_topping}.")
print("nFinished making your pizza!")

---

python的第二个玩具字典

在python中字典是一系列键值对，每个键都与一个值相对应，可以使用键来访问相关联的值。与键相关的值可以是字符串，列表，数乃至字典，在python中使用花括号来表示一个字典中的键值对。

alien_0={'color':'green','points':5}
'''第二种表达方式'''
alien_0={
    'color':'green',
    'points':5,
    }#当字典中的键值对比较多的时候，推荐第二种方式的，条理清晰。
print(alien_0['color'])
print(f"you are have a {alien_0['color']}")#如果要用print直接输出，需要用f来表示是组合字符串
alien_0['x_position']=0
alien_0['y_position']=25#在字典中创建了新的键值对'y_position':25
print(alien_0)
这个时候你会看到输出-->
{'color': 'green', 'points': 5, 'x_position': 0, 'y_position': 25}

同样也可以创建一个新的字典，通过 字典名[键名]=值名，键可以是数字、字符串、元组（除 list、dict、set外）

修改字典中的值和修改数组中的值一样 字典名[键名]=值名（这个值可以包含某个键）

删除键值对，可以使用del语句，必须指定字典名和要删除的键。

即 del alien_0[‘color’]

alien_0={'color':'green','points':5}
print(alien_0)
del alien_0['points']
print(alien_0)
输出如下所示
{'color': 'green', 'points': 5}
{'color': 'green'}

使用get（）方法来访问值

get（）需要两个参数，第一个是字典的键名（必不可少），第二个是如果没有这个键名将会返还的值,使用逗号隔开。

alien_0={'color':'green','points':5}
a=alien_0.get('speed')
print(f'it is {a}')
因为这个get并没有包含第二个参数，所以不包含这个键的时候，返还值默认是none

遍历字典（可以遍历键值对，也可以只遍历值或者键）

遍历所有键值对

user_0={
    'username':'efermi',
    'first':'enrico',
    'last':'fermi',
    }
for key,value in user_0.items():
#这个语句中，包含两个形参key，value[但是第一个值永远表示键，另一个表示值]，。items（）这个方法将会返还一个键值对列表，即把字典转化为列表的形式。
    print(f"key is:{key},value is:{value}")

把这个.items（）改成.keys（）即为遍历所有的键，如果需要对键进行排序并且遍历的话可以如下操作

for key in sorted(user_0.keys())

对所有值进行遍历，使用.values（）这个方法，提取字典所有值，但是没有考虑重复。当字典中重复值过多的话可以采用集合（set）。通过对包含重复元素的列表调用set（）来提取字典中不同的元素。

for value in set(user_0.values())

因为方法.tittle(),.values(),.keys()返回值是一个列表。所以我们也可以把它放入if语句之中

if 'iuuy' not in user_0.keys()

---

字典列表（套娃又开始了）

可以用一个列表来存储不同的字典

alien_0={'color':'green','points':5}
alien_1={'color':'red','points':6}
alien_2={'color':'yellow','points':9}
alien_3={'color':'blue','points':4}
aliens=[alien_0,alien_1,alien_2,alien_3]
        在字典中储存列表
pizzas={
    'crust':'thick',
    'toppings':['mushrooms','extra cheese'],
    }
print(pizzas['toppings'])
#遍历字典中的列表
for key,value in pizzas.items():
    for a in value:
        print(a)
#这个时候会输出-->
t
h
i
c
k
mushrooms
extra cheese
#如果把代码改为
pizzas={
    'crust':['thick'],
    'toppings':['mushrooms','extra cheese'],
    }
for key,value in pizzas.items():
    for a in value:
        print(a)
#输出会是
thick
mushrooms
原因是
        字典中嵌套字典
users={
    'aeunstein':{
        'first':'albert',
        'last':'curie',
        'location':'paris',
        },
    'murie':{
        'first':'marie',
        'last':'curie',
        'location':'paris',
        },
    }
for value1 in users.values():
    for value2 in value1.values():
        print(f"{value2}n")#遍历字典中的字典中的各个值

---

用户输入和while循环

函数input（）的工作原理：让程序暂停运行，等待用户输入一些文本。获取用户输入后，python将其赋值给变量。函数input接受一个参数，也就是要向用户现实的提示或说明。

message=input(tell me something and I will repeat again)
print(message)
input()函数在用户输入之后根据回车截断内容把值赋给变量message。
#创建多行提示
prompt='if you tell us who you are,we can personalize the messsage you see'
prompt+='nwhat is your first name:'
print(f"your first name is {prompt}!")

使用int（）来处理数值输入，因为input（）读入的数据将会以字符串的形式存在，但是我们在if语句中如果要拿他和数值进行比较，就需要把他转化为int类型所以需要int（）函数

height=input('how tall are you,in inches?')
height=int(height)
if height>=48:
    print('you are so tall')
else:
    print('you are so short')

while循环简介：在python中的while循环和c基本相同，所以摆一行代码来体验一下while循环的基本格式和规范即可

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

---

使用标志

标志就是用于判断的第三方变量，可以利用这个变量的值作为if语句的判断表达式，这样可以更好地控制循环的运行。

又见break，continue：

这两个也是c语言中的老朋友了，不多讲。break用于跳出当前所在的那一重循环，常与if语句搭配使用，告诉计算机当遇到什么情况时我们可以跳出循环。continue就是跳过该轮循环余下的代码，转而执行下一个循环。

使用while循环处理列表和字典

不应该在for循环中更改列表的元素，所以我们一般采用while循环来处理列表。

1.在列表之间移动元素

unconfirmed_users=['alice','brian','candace']
confirmed_users=[]
while unconfirmed_users:
    current_user=unconfirmed_users.pop()
    confirmed_users.append(current_user)#这样就完成了两个列表元素之间的交换

2.因为remove（）方法只能删除列表中的某一个特定值，所以我们要采用循环来删除列表中的重复的特定值

numbers=[1,2,3,4,4,4,4]
numbers.remove(3)
print(numbers)
#上面的代码会输出[1,2,3,4,4,4]只会少掉一个4
while 4 in numbers:
    numbers.remove（4）
print(numbers)
#上面的代码会输出[1,2,3]
        3.使用用户输入来填充字典
responses={}
polling_acitive=true
while polling_active:
    name=input()
    response=input()
    responses[name]=response
if name==...：#填入任意值都可以，来控制循环的结束与否
    polling_active=false

函数

定义一个函数，在python中定义一个函数

def greet_user():#告诉程序我要定义一个函数，函数名字叫做greet_user
def greet_user(username)#和c语言一样可以在（）之间加一个形参传入函数
#python中的函数操作与c语言基本相同，同样用return来表示返回值（可以是字典，列表等复杂类型的数据），也同样按照顺序把实参的值赋给形参。
#python可以使用关键字实参（=两边不能有空格）
def greet_user(firstname,lastname):
print(f'you name is {firstname} {lastname}')
我们在调用这个函数时可以输入
greet_user(lastname='albert',firstname='viking')但是python中的函数可以提供默认值（提供默认值时等号两边也不能有空格），也就可以把实参变成可选择性的输入
def greet_user(first_name,middle_name='',last_name):#这一步操作使得middle_name的默认值是空，也就是说如果不提供middle_name这个实参，就会使得在函数体中的所有middle_name的值为空，此时middle_name这个实参就变成了一个可选择的实参还有一个注意点是，相比c语言python函数所传入的实参并没有被指定特定的类型，形参也是，这就是意味着python更容易犯错但是也更具有灵活性。

一般来说，在函数中修改列表是永久性修改（和c语言中的数组相类似）

#我们可以通过切片的方式传入列表副本，从而防止列表本身在函数中被修改
def quicksort(list1)#定义了这样一个函数之后
我们在调用它时，只要传入副本即可；
quicksort（list1[:]）

传递任意数量的实参

可以使用形参*加上形参名，来表示一个可以接受任意数量实参的形参。这里的*告诉计算机创建一个元组，所有被传入的形参都会被传入到这个元组之中。

def make_pizza(*toppings):
    print("nmaking a pizza with the following toppings:")
    for topping in toppings:
        print(f"-{topping}")
make_pizza('pepperoni')
make_pizza('mushrooms','green peppers','extra cheese')

结合使用位置实参和任意数量实参

def make_pizza(topictopping，*toppings):
    print("nmaking a pizza with the following toppings:")
    for topping in toppings:
        print(f"-{topping}")
#这样传入函数的第一个实参会交给topictopping而后面所有的实参都传入元组toppings

使用任意数量的关键字实参(关键字实参的等号两边不能有空格)

def build_profile(first,last,**user_info):
    user_info['firstname']=first
    user_info['lastname']=last
    return user_info
user_profile=build_profile('albert','einstein',
                                            location='princetion'
                                            field='physics')
#如果需要传入的参数过多可以几个换行，只要对其缩进即可函数定义时也可以这么干
print(user_profile)
会输出
{'location': 'princetion', 'field': 'physics', 'firstname': 'albert', 'lastname': 'einstein'}

---

将函数储存在模块中并且导入该模块

先创建一个模块，里面可以包含多个函数比如创建一个build_profile.py的文件
def build_profile(first,last,**user_info):
user_info['firstname']=first
user_info['lastname']=last
return user_info然后在build_profile.py这个文件的目录中创建一个新的源代码new.py（一般就是放在同一个文件夹里面就可以了）import build_profile#被导入模块.函数名build_profile.build_profile(实参1，实参2....)

导入模块中特定函数

from module_name import function_0,function_1,function_2
function_1(实参1，实参2)#这个时候就不用模块名.这个结构了
#这就会从module_name这个模块中导入function_0,function_1,function_2这三个函数给函数指定别名from module_name import function as m1
m1（实参1，实参2）#m1函数就代表了function这个函数同样我们也可以给模块指定别名
import build_profile as bp#这样我们可以直接使用bp.function来调用build profile里面的函数也可以直接import matplotlib.pyplot as pyp
导入matplotlib库中的pyplot函数，别名为pyp我们可以直接导入模块中的所有函数（最好直接import）
from build_profile import *

类（面向对象）

创建和使用类，使对象实例化

我们创建一个dog类

class Dog:
    def __init__(self,name,age):#形参可以不止两个
        self.name=name
        self.age=age
    def sit(self):
        print(f"{self.name} is now sitting")
    def roll_over(self):
        print(f"{self.name} rolled over")
#同样我们也可以创建一个读入参数的方法
    def roll_meters(self,meter):
        print(f"you have already rolled {meter} meters")

方法__init__（）：init是旁边各两个下划线类中的函数称为方法。在前面学习过的一切函数的内容都适用于方法。_init_()是一个特殊的方法，每次根据dog类创建新实例时，python都会自动运行它。为了凸显它的特殊所以两边各有一个下划线作以区分。为什么方法定义中包含形参self呢，因为python调用这个方法来创建实例的时候，自动会传入实参self，它是一个指向实力本身的引用，让实例可以访问类中的属性和方法。以self为前缀的变量可供类中所有的方法使用，可以通过类的任何实例来访问，，像这样可以通过实例访问的变量称为属性。

同样创建了新的方法在上述样例之中，创建了两个新的方法，sit()和roll_over()

访问属性和调用方法

my_dog=Dog('willie',6)
print(my_dog.name)#属性通过实例.属性名进行访问
my_dog.sit()-->会输出willie is now sitting

给属性指定默认值(如果他的属性中不止有一个默认属性还有一个普通属性，只有两个参数都传入才会修改这个默认属性，否则的话直接跳过，给第二个普通属性)

属性默认值要放在后面，不能放在普通的值前面。

class Car:
     def __init__(self,make,model,year):#需要传入的属性
#真正包含的所有属性
        self.make=make
        self.model=model
        self.year=year
 self.odometer_reading=0#给属性值的默认值
  def read_odometer(self):
        print(f"This car has {self.odometer_reading} miles on it.")

直接修改属性的值

my_new_car=Car('audi','a4',2019)
my_new_car.odometer_reading=23
my_new_car.read_odometer()

通过方法修改属性的值

需要在类里面加上一个新的方法
    def update_odometer(self,mileage):
        self.odometer_reading=mileage
#我们在里面加上新的要求，让它不能把里程数往回调
        if mileage>=self.odometer_reading:
            self.odometer_reading=mileage
        else:
            print("you can't roll back an odometer!")

通过方法对属性进行了递增

def update_odometer(self,mileage):
        self.odometer_reading+=mileage

继承

父类和子类的继承，子类会继承父类的所有属性和方法，同时还可以定义自己的属性和方法。

子类的方法__init__()

在既有类的基础上编写新类时，通常要调用父类的方法__int__()。这将初始化在父类__init__()方法中定义的所有属性，从而让子类包含的属性。电动汽车是一种特殊的汽车，因此可在前面创建的car类的基础上创建新类electriccar。

class Car:
    def __init__(self,make,model,year):
        self.make=make
        self.model=model
        self.year=year
        self.odometer_reading=0
    def read_odometer(self):
        print(f"This car has {self.odometer_reading} miles on it.")
class electriccar(Car):
    def __init__(self,battery_size,model,year,make):
 super().__init__(make,model,year)#初始化父类属性(继承)
 self.battery_size=battery_size#增加子类新的属性
    def control(self):
 print("your car is under control")#增加子类的新的方法

重写父类的方法

对于父类的方法，只要他不符合子类的属性和特征就可以对父类的方法进行重写，可以在子类中定义一个与要重写的父类方法同名的方法。这样python不会关注父类的方法，会关注你在子类中定义的相应方法。

class Car:
     def __init__(self,make,model,year):
        self.make=make
        self.model=model
        self.year=year
        self.odometer_reading=0
    def read_odometer(self):
        print(f"This car has {self.odometer_reading} miles on it.")
class electriccar(Car):
    def __init__(self,battery_size,model,year,make):
        super().__init__(make,model,year)#初始化父类属性(继承)
        self.battery_size=battery_size#增加子类新的属性
    def control(self):
        print("your car is under control")#增加子类的新的方法
#我们假设在父类中有一个fill_gas_tank()的方法，因为他对电动汽车毫无作用，所以我们可以对他进行改写。
    def fill_gas_tank(self):
        print('this car dosen't need a gas tank')                                           
        将实例用做属性。当我们的某一个类拥有过多的属性和方法，我们可以为它们专门创建一个新的实例，然后在属性中添加该实例。
#例如我们可以给electriccar添加一个新的实例叫做battery。
class Battery:
    def __init__(self,years,battery_size=75):
        self.battery_size=battery_size
        self.years=years
    def reading_battery_size(self):
        print(f"this electriccar has{self.battery_size}")
class Electriccar(Car):
    def __init__(self,color,Battery,make,model,year):
 super().__init__(make,model,year)#继承父类属性
        self.color=color
 self.battery=Battery()#将实例Battery添加到Electricbattery的属性中
my_tesla=Electriccar('yellow',24,33,5)
#这个时候，其实我们把‘yellow’给了color，把24给了make，把33给了model，把5给了year。但是却没有参数给了Battery这个实例属性。如果需要把参数传给这个实例属性，我们需要一个中间量。
m=Battery(80,5)#如果只输入了一个5，默认修改了years，而battery_size还是会是初始值75
my_tesla=Electriccar('yellow',m,24,33,5)
my_tesla.battery.reading_battery_size()#在这里，先通过my_tesla.battery来访问了battery这个属性，同时通过.reaing_battery_size()访问了Battery这个类中的方法。

导入类

#假如类Car被储存在car.py这个文件中，我们怎么样导入这个类呢
from car import Car#如果一个文件中包含很多的类，我们想要导入
from car import Car，Electriccar#同样我们可以导入一整个模块
import car
my_car=car.Car('......')#通过module_name.Classname访问需要的类。#导入模块中的所有类
from module_name import *#使用别名
from electric_car import ElecatricCar as EC#这样我们就可以用EC来代表二了EletricCar
my_car=EC(24,34,54)

学习标准库

自己学详见python官网

文件和异常

读取整个文件

下面首先创建一个文件pi_digits.txt，用以下程序打开

#文件file_reader.py
with open('pi_digits.txt') as file_object:
contents=file_object.read()
print(contents)
#open()函数，open函数可以打开一个文件，接受一个参数：要打开的文件的名称。当前运行的是file_reader.py，因此python在file_reader.py所在的目录中查找pi_digits.txt。open（）返还一个表示文件的对象，python将该对象赋给file_object供以后使用。使用方法read（）读取这个文件的全部内容，并将其作为一个长长的字符串赋给变量contents。这样通过打印contents的值，就可将这个文本文件的内容全部显示出来。read（）函数的末尾，会自动留下一行空白，所以如果需要去除空白，我们要调用方法.strip().或者rstrip()

将类似于pi_digits.txt的简单文件名传递给函数open（）时，python将在当前执行的文件所在的目录中查找。比如我们把file_reader.py这个文件保存在python_work这个文件夹之中，所以我们就会在文件夹下寻找pi_digits.txt这个文件，但是如果我们把pi_digits.txt放在python_work的一个子文件夹text_files之中，我们的编译器就会报错，因为他不会打开python_work的子文件夹。但是因为text_files这个文件夹在python_work这个文件夹之中，所以我们可以利用相对文件路径打开这个文件。

with open('text_files/pi_digits.txt') as file_object:
#这行代码，让python程序在包含file_reader.py的python_work这个文件下的text_files文件夹中打开pi_digits.txt这个文件，可以认为是pi_digits.txt相对于file_reader.py路径位置
#也可以用绝对路径打开文件，也就是这个文件在计算机的哪个内存区域之中，一般比较繁琐（不推荐）

逐行读取

filename='pi_digits.txt'#只是把文件名放置在在一个字符串变量之中方便下次打开
with open(filename) as file_object:
 for line in file_object:
 print(line)#一个for循环逐行读取同样因为文件自带换行符，同时每次print就会自动包含一个换行符，所以我们可以调用rstrip（）来消除多余空白
        创建一个包含文件各行内容的列表
filename='pi_digits.txt'
with open(filename) as file_object:
    lines=file_object.readlines()
#readlines（）从file_object读取每一行储存在lines这个列表中，这个列表的每一个元素都代表文件中的一行。
for line in lines:
    print(line.rstrip())
        使用文件的内容
filename='pi_digits.txt'
with open(filename) as file_object:
    lines=file_object.readlines()
pi_string=''
for line in lines
    pi_string+=line.strip()
print(pi_string)
print(len(pi_string))
#因为单纯输出列表会包含列表的格式，所以我们可以把它给我们的字符串，然后再输出
        如果文件太长我们只想输出其中一段可以用切片的方式，切片和对列表的切片相类似。
print(pi_string[:50].strip())

我们可以写入文件了，利用python的快乐hhh

filename='programming.txt'
with open(filename,'w') as filework:
filework.write('I Love Programming.')

在这之中，open（）多了第二个参数，‘r’代表读取模式；‘w’代表写入模式；‘a’表示附加模式；‘r+’表示读写模式，没有第二个参数默认读取模式。如果要写入的文件不存在，python会自动创建它，但是如果该文件已经存在，当我们以写入模式打开这个文件时会清空原先这个文件所包含的内容。

python只能将字符串写入txt文件之中，所以我们如果要将数值写入该文件，就必须使用

str（）函数将数值转化为字符串

写入多行

filename='programming.txt'
with open(filename,'w') as filework:
filework.write('I Love Programming.n')
filework.write('yep!n')

附加到文件之中

如果要给文件添加内容，又不会删去原先文件的内容，可以以附加模式打开这个文件。附加模式之中只会讲写入文件的行添加到文件的末尾。如果指定的文件不存在，会创建一个空文件。例如上文操作过的那个文件

filename='programming.txt'
with open(filename,'a') as filework:
filework.write('I Love cs.')

打开文件时指定了实参‘a’，这样当我们打开这个文件后，文件就会包含多行内容

I Love Programming.
yep!
I Love cs