python语法基础

第一章：变量和简单的数据类型

1.2 变量

python是一门脚本语言，与HTML一样。书写非常简便。变量的声明与c++有着很大的区别，不用声明变量类型，语句末尾不用“;”

增加一个名为message的变量

message="hello python worla！"

1.2.1 变量的命名与使用

1.变量名只能包括字母、数字和下划线。变量名能以字母或下划线打头，不能以数字打头`。
2.变量名不能包含空格，应该使用下划线分隔其中单词。
3.不能将python中的关键词与函数名当作变量名
4.变量名应该简短而且具有描述性
5.慎用小写字母l与大写O，与数组0和1不容易分清楚。

1.3字符串

字符串就是一系列的字符，用单引号或者双引号括起来

1.3.1使用方法修改字符串的大小写

name="ada lovelace"

使用title，将每个单词的首字母大写

print(name.title())
#结果应该是
Ada Lovelace

使用upper，将每个单词的字母大写

print(name.upper())
#结果应该是
ADA LOVELACE

使用lower，将每个单词的字母小写

1.3.2在字符串中使用变量

要在字符串中插入变量的值，可以在引号前面加上字母f，然后把要插入字符串的变量放在花括号里

first_name=ada
last_mane=lovelace
print(f"my name is {first_name} {last_name}")
#结果应该是
my name is ada lovelace

1.3.3使用制表符或换行符来增加空白

\n换行 \t增加空格

1.3.4删除空白

使用rstrip消除后面的空格

#后面有空格
name="python "
print(f"{name.rstrip()}good")
#结果是
pythongood
print(f"{name}good")
#结果是
python good

使用lstrip消除前面的空格

#前面有空格
name=" python"
print(f"{name.lstrip()} good")
#结果是
python good
print(f"{name} good")
#结果是
 python good

使用strip消除前后所有的空格

#前后都有空格
name=" python "
print(f"{name.strip()}good")
#结果是
pythongood
print(f"{name}good")
#结果是
 python good

1.4数

整数：加减乘除运算
平方：**
整数与浮点数运算，结果是浮点数。
如果数字比较长可以增加_分割，便于阅读，不影响结果\

number=14_000_000_000

同时给多个变量赋值：

x,y,z=1,2,3

常量：全部大写说明该数为常量

MAX_COMECTIONS = 5000

1.5注释

#大家好，我是python

第二章：列表简介

2.1列表是什么？

  由一系列按特定顺序排列的元素组成，可以将任何东西加入列表中，其中的元素之间可以没有关联，因为列表中常常有多个元素，因此列表名往往是一个复数的名称
  方括号[]表示列表，用逗号分隔其中的元素

bicycles=['trek','cannondale','redline']
print(bicycles)
#结果是
['trek','cannondale','redline']

2.1.1访问列表元素

列表是有序集合，访问列表的任意元素，只需要将元素的位置告诉python：列表名称，元素的索引，后者放入方括号内

bicycles=['trek','cannondale','redline']
print(bicycles[0])
#结果是
trek

第一个列表元素索引并不是1，而是0，大部分编程语言均是如此，为了方便访问，若列表元素过多，python提供一种特殊语法，直接访问最后一个元素。

print(bicycles[-1])
#结果是
redline
print(bicycles[-2])
#结果是
cannondale
#于此类推...

2.2修改，增加和删除元素

修改：

bicycles=['trek','cannondale','redline']
bicycles[1]='honda'
print(bicycles)
#结果是
['trek','honda','redline']

增加元素：

bicycles=['trek','cannondale','redline']
bicycles.append('honda')
print(bicycles)
#结果是
['trek','cannondale','redline','honda']
#只在列表末尾处增加

bicycles=['trek','cannondale','redline']
bicycles.insert(0,'honda')
print(bicycles)
#结果是
['honda'.'trek','cannondale','redline']
#指定位置增加元素

删除元素：

bicycles=['trek','cannondale','redline']
del bicycles[0]
print(bicycles)
#结果是
[cannondale','redline']

弹出某个元素：如果pop后括号内没有声明索引，则默认弹出最后一个元素

bicycles=['trek','cannondale','redline']
a=bicycles.pop(1)
print(a)
print(bicycles)
#结果是
cannondale
['trek','redline']

根据值删除元素：remove只能删除第一个特定的值，如果重复多次，需要循环

bicycles=['trek','cannondale','redline']
bicycles.remove('trek') 
print(bicycles)
#结果是
bicycles=['cannondale','redline']

2.3组织列表

使用sort()方法对列表永久排序：按首字母顺序

bicycles=['trek','cannondale','redline']
bicycles.sort()
print(bicycles)
#结果是
['cannondale','redline','trek']

使用sorted()对列表临时排序：但原来bicycles列表顺序不变

bicycles=['trek','cannondale','redline']
print(sorted(bicycles))
#结果是
['cannondale','redline','trek']

倒着打印列表:按照原列表的反顺序

bicycles=['trek','cannondale','redline']
bicycles.reverse()
print(bicycles)
#结果是
['redline','cannondale','trek']

确定列表的长度：

bicycles=['trek','cannondale','redline']
a=len(bicycles)
print(a)
#结果是
3

第三章：操作列表

3.1 遍历整个列表

获取一个列表中所有元素

magicians = ['alice','david','carolina']
for magician in magicians:
   print(magician)
#结果是
alice
david
carolina

3.2在for循环中执行更多操作

删除空格，字符大小写变化等等操作都可以添加

magicians = ['alice','david','carolina']
for magician in magicians:
  print(f"{magician.title()},that is a great magician!" )
#结果是
Alice,that is a great magician!
David,that is a great magician!
Carolina,that is a great magician!

3.3创建数值列表

3.3.1使用函数range()

生成一系列数

for number in range(1,5):
  print(number)
#结果是
1
2
3
4
#到5停止打印，因此没有5

3.3.2使用range()创建数字列表

需要使用list()将range()的结果转换为列表

numbers = list(range(1,6))
print(numbers)
#结果是
[1,2,3,4,5]

使用range()生成数时，还可以规定步长
比如生成2-11之间的偶数

numbers = list(range(2,11,2))
print(number)
#结果是
[2,4,6,8,10]

生成1-5的平方数

squares =[]
for number in range(1,6):
  square =number**2
  squares.append(square)
print(squares)
#结果是
[1,4,9,16,25]

3.3.3对数字列表进行简单的统计计算

dights = [1,2,3,4,5,6,7,8]
min(digths)
-----1
max(digths)
-----8
sun(dights)
-----36

3.4使用列表的一部分

3.4.1切片

要创造切片，可指定要使用的第一个元素和最后一个元素的索引，

players =['charles','martina','michael','florence','eli']
print(players[0:3])
#结果是
['charles','martina','michael']

可以指定任何子集，比如第二，第三和第四元素

print(players[1:4])

没有指定第一个索引，将默认从第一个开始

print(players[:3])

3.4.2遍历切片

不遍历整个列表，只遍历指定切片

players =['charles','martina','michael','florence','eli']
for player in players[1:4]
  print(player)
#结果是
martina
michael
flarence

3.4.3复制列表

要复制整个列表，我们需要建立一个包含整个列表的切片，方法是同时省略起始索引跟终止索引

players =['charles','martina','michael','florence','eli']
M_players = player[:]
print(M_players)
['charles','martina','michael','florence','eli']

3.5元组

列表适合存储在程序运行中需要变化的数据集，但有些元素是不可修改的，元组可以满足这一要求

3.5.1定义元组

用圆括号而非中括号标识，用法与列表一样，但不能修改

names = ('kyle','mark')

3.5.2遍历元组的所有值

用法与列表一样

names = ('kyle','mark')
for name in names:
  print(name)
#结果是
kyle
mark

3.5.3修改元组变量

虽然不能修改某个具体的值，但可以整体重新赋值

names = ('kyle','mark')
#重新赋值
names =('simth','jack')
for name in names:
  print(name)
#结果是
simth
jack

第四章 if语句

4.1简单示例

普通汽车名，全部大写打印，如果是bmw，只首字母大写打印即可

cars=['audi','bmw','subaru','toyota']
for car in cars:
  if car =='bmw':
    print(car.title())
  else:
    print(car.upper())

4.2条件测试

每个if语句后跟的都是一个值为True或False的表达式，根据值来决定是否执行if后面的代码

4.2.1检查是否相等

‘=’表示赋值，‘==’表示判断是否相等

car = bmw
car =='bmw'
#结果是
True

检查相等时忽略大小写

4.2.2检查是否不相等

使用‘！=’

4.2.3数值比较

相等与字符方法相同
<,>,<=,>=。用法相同

4.2.4检查多个条件

and和or

4.2.5检查特定值是否包含在列表中

cars = ['bmw','make']
'bmw' in cars
#结果是
True

4.2.6检查特定值是否不包含在列表中

names =['jack','mark','smith']
name = 'kyle'
if name not in names:
  print(f"{name.title()},you are not a name"")
#结果是
Kyle,you are not a name

4.2.7布尔表达式

条件测试的别名，与其他条件表达式一样，结果只有两种。

4.3 if语句

4.3.1 简单的if语句

前面有演示，记得if语句里的代码要缩进

4.3.2 if-else语句

如果条件测试通过执行一个操作，没通过，执行另一个操作。

age = 17
if age <= 18:
  print("you are too young!")
else:
  print("good")
#结果是
you are too young!

4.3.3 if-elif-else结构

检查多个条件

age = 16
if age < 10:
  a = 1
elif age < 18:
  a = 2
else:
  a = 3
print(a)
#结果是
2

4.3.4使用多个elif代码块

可以使用多个elif代码块

4.3.5省略else代码块

else包括不符合if和elif的其他所有语句，有时候需要一个elif去结束if语句，而省略else

4.4 使用if语句处理列表

4.4.1 检查特殊元素

names =['jack','mark','smith']
for name in names:
  if name == 'jack':
    print("1")
  else:
    print("2")
#结果是
1
2
2

4.4.2 判断列表是否为空

不为空，执行for循环，为空，则执行另一个操作

4.4.3 使用多个表

第五章 字典

5.1 使用字典

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

people = {'name':'jack','sex'='man'}

5.2访问字典的值

要获取与键相关联的值，可依次指定字典名和放在方括号内的键

print(people['name'])
#结果是
jack

5.2.2增加键值对

字典是一种动态结构，可以随时增加键值对。指定字典名，用方括号括起的键和相关联的值

people = {'name':'jack','sex'='man'}
people['grade'] = 1
people['hobit'] = soccer
print(people)
#结果是
{'name':'jack','sex'='man','grade'=1,'hobit'='soccer'}

5.2.3创建空字典

使用字典来存储用户提供的数据或在编写能自动生成大量键值对的代码时，通常需要先定义一个空字典

people = {}

5.2.3修改字典中的值

要修改字典中的值，可依次指定字典名，用方括号括起来的键，以及新值

people = {'name':'jack','sex'='man'}
people['name']='smith'
print(people)
#结果是
people = {'name':'smith','sex'='man'}

5.2.4删除键值对

people = {'name':'jack','sex'='man'}
del people['sex']
print(people)
#结果是
people = {'name':'jack'}

5.2.5由类似对象组成的字典

之前的实例中，字典存储的是一个对象的多种信息，我们也可以用字典存储众多对象的同一信息

language = {
  'jack':'c++',
  'smith':'python',
  'kyle':'java',
}

5.2.6使用get()来访问值

使用方括号的键从字典中获取感兴趣的值时，如果指定的键不存在，就会报错。
方法get(),第一个参数用于指定键，是必不可少的；第二个参数为指定的键不存在时要返回的值。

people = {'name':'jack','sex':'man'}
a = people.get('point','No point value assigned')
b = people.get('name','No name value assigned!')
print(a)
#结果是
No point value assigned
jack

5.3遍历字典

5.3.1遍历所有键值对

要遍历字典得for循环，可声明两个变量，用于存储键值对中的键和值。

people = {'name':'jack','sex':'man'}
for key,value in people.items():
  print (f"\nkey:{key}")
  print (f"value:{value}")
#结果是
key:name
value:jack

key:sex
value:man

5.3.2遍历字典中的所有键

在不需要使用字典中的值时，方法keys()很有用。

people = {'name':'jack','sex':'man'}
for a in people.key():
  print(a)
#结果是
name
sex

5.3.3按特定顺序遍历字典中的所有键

使用sorted()来获得按特定顺序排列的键列表得副本

languages = {
    'jen':'python',
    'sarah':'c',
    'edward':'ruby',
    'phil':'python'
}
for name in sorted(languages.keys()):
  print(name)
#结果是
edward
jen
phil
sarah

5.3.4遍历字典中的所有值

使用values()来返回值，不包括任何键

languages = {
    'jen':'python',
    'sarah':'c',
    'edward':'ruby',
    'phil':'python'
}
for language in languages.values():
  print(language)
#结果是
python
c
ruby
python

提取字典中的所有值，并没有考虑是否重复，要剔除重复项，可使用集合(set),集合中的每个元素都必须是独一无二的

for language in set(languages.values()):
  print(language)
#结果是
python
c
ruby

5.4 嵌套

创建三个字典，每个字典都是一个人的信息，然后将三个字典存储到一个列表中。

people1={'name':'jack','language':'python'}
people2={'name':'kylw','language':'c'}
people3={'name':'smith','language':'java'}
peoples=[people1,people2,people3]
print(peoples)
#结果是
{'name':'jack','language':'python'}
{'name':'kylw','language':'c'}
{'name':'smith','language':'java'}

5.4.1在字典中存储列表

people={'name':'jack','languages':['java','python','c']}

5.4.2在字典中存储字典

peoples={
   ' people1':{
       'name':'jack',
       'language':'python',
   },
   'people2':{
       'name':'smith',
       'language':'c'
   }
}

第六章 用户输入和while循环

6.1函数input()的工作原理

函数input()让程序暂停运行，等待用户输入一些文本。获取用户输入后，Python将其赋给一个变量。

message = input("Tell me a thing:")
print(message)

6.1.2编写清晰的程序

如果提示有多行，可以将提示赋给一个变量，再将这个变量传给input()函数

message = "i want your name"
message +="\nwhat is your name: "
name = input(message)

6.1.3使用int()来获取数值输入

我们使用input()获取用户输入的值，即使是数字，我们获得的确是字符串类型的，如果需要跟一个数比较，则需要将获得的字符串“数字”，转换成数值

age = input("how old are you? ")
age = int(age)
if age > 18:
 print("hello")

6.1.4求模运算符

求模运算符（%）是个很有用的工具，它将两个数相除并返回余数：

4%3
1
5%3
2
6%3
0

通过和2执行求模运算来判断该数的奇偶性

6.2while循环简介

for循环用于针对集合中的每个元素都执行一个代码块，而while循环则不断运行，知道指定的条件不满足为止

6.2.1使用while循环

使用while循环数数

number = 1
while number <5:
  print(number)
  number +=1
#结果是
1
2
3
4
5

6.2.2让用户选择何时退出

prompt ="\ntell mo something,i will repeat it to you"
prompt = "\nenter'quit'to end the program"
message = ''
while  message != 'quit':
  message = input(promt)
  print(message)

6.2.3使用标志

在要求很多条件都满足才继续运行的程序中，可定义一个变量，用于判断整个程序是否处于活动状态,这个变量我们称为标志，充当程序的交通信号灯。可以让程序在标志为True时继续执行，并在标志为False时让程序停止运行。

prompt ="\ntell mo something,i will repeat it to you"
prompt = "\nenter'quit'to end the program"
message = ''
active = True
while  active:
  message = input(prompt)
  if message == 'quit':
    active = False
  else:
  print(message)

6.2.4使用break退出循环

要立刻退出while循环，不再运行循环中余下的代码，也不管条件测试的结果如何，可使用break语句。

prompt ="\ntell mo something,i will repeat it to you"
prompt = "\nenter'quit'to end the program"
while  True:
  message = input(prompt)
  if message == 'quit':
    break
  else:
  print(message)

6.2.5在循环中使用contiune

要返回循环开头，并根据条件测试结果决定是否继续执行循环，可使用continue语句，它不像break语句那样不再执行余下的代码并退出整个循环。

number = 1
while number<10:
  number +=1
  if number%2 == 0:
    continue
  print(number)

6.2.6避免无限循环

如果程序陷入无限循环，可按Ctrl+C

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

friend_nums = ['1','2','3']
my_nums = []
while friend_nums:
  number = friend_nums.pop()
  my_nums.append(number)
for num in my_nums:
  print(num)
#结果是
1
2
3

6.3.2删除为特定值的所有列表元素

numbers = ['1','2','1','3','1']
print(numbers)
while '1' in numbers:
  numbers.remove('1')
print(numbers)
#结果是
['1','2','1','3','1']
['2','3']

6.3.3使用用户输入来填充字典

actives = True
dogs = {}
while actives:
  name = input("\nwhat is you name?")
  dog = input("what dog would you like?")
  dogs[name] = dog
  repeat =input("anyone else?(yes/no)")
  if repeat =='no':
    actives = False
print("show all databases:")
for name,dog in dogs.items():
  print(f"{name} like {dog}")

第七章 函数

7.1 定义函数

使用def定义函数名，后面必须带圆括号，里面跟参数。下面可以有文档注释串

def index():
  """这是文档注释串"""
  print("hello world")
index()
#结果是
hello world

7.1.1 向函数传递信息

通过给括号内指定参数，给函数传值

def index(name):
  print(f"hello {name.title()}!")
index('kyle')
#结果是
hello Kyle!

7.1.2 实参与形参

在上述函数定义时，变量(name)是一个***形参***，即函数完成工作所需的信息。在代码index(‘kyle’)中’kyle’是***实参***，即调用函数所传递给函数的信息。

7.2 传递实参

函数定义中可能包括多个形参，因此函数调用中也可能包括多个实参。向函数传递实参的方式有很多：位置实参，关键字实参，列表和字典。

7.2.1 位置实参

实参与形参的顺序相同，调用函数时，python必须将函数调用中的每个实参都关联到函数定义中的一个形参(可以多次调用，给不同实参；一定要注意实参顺序)

def index(my_name,friend_name):
  print(f"{my_name} is {friend_name}")
index('kyle','smith')
#结果是
kyle is smith

7.2.2 关键字实参

传递给函数名称对，直接在实参中将名称和值关联起来，所以不用考虑实参位置

def index(my_name,friend_name):
  print(f"{my_name} is {friend_name}")
index(friend_name='smith',my_name='kyle')#顺序与形参顺序不相符，但没影响
#结果是
kyle is smith

7.2.3 默认值

定义函数时，可给每个形参指定默认值，如果调用函数时没有给该变量传递实参，则使用默认值

def index(my_name,friend_name='jack'):
  print(f"{my_name} is {friend_name}")
index(my_name='smith')
#结果是
smith is jack

index('kyle')
#结果是
kyle is jack

index(friend_name='smith',my_name='kyle')#给有默认值的形参传递实参，将忽略其默认值
#结果是
kyle is smith

7.2.4 等效的函数调用

位置实参，关键字实参以及默认值可以混合使用，一种输出可以有多种调用方式

def animals(name,type='dog'):
......

#名叫willie的狗
animals('smith')
animals(name='smith')

#名叫jack的猫
animals('jack','cat')
animals(name='jack',type='cat')
animals(type='cat',name='jack')

7.2.5 避免实参错误

调用函数后，如果实参不匹配，程序将会报错

7.3 返回值

函数并非总是直接显示输出的，同样可以处理一些数据，返回一个值或者一组值

7.3.1返回简单值

def get_name(first_name,last_name):
  name=f"{first_name.title()} {last_name.title.()}"
  return name
my_name=get_name('smith','jack')
print(my_name)
#结果是
Smith Jack

7.3.2让实参变成可选的

def get_name(first,last,middle=''):
  if middle:
    name=...
  else:
    name=...

7.3.3返回字典

def peoples(name,dog):
  peoples={'name'=name,'dog'=dog}
  return people
people = peoples('jack','smith')
print(people)
#结果是
{'name'='jack','dog'='smith'}

也可以给函数定义时增加一个空的形参，给用户传递实参时提供选择

7.3.4结合使用函数和while循环

def get_name(first_name,last_name):
  name=f"{first_name.title()} {last_name.title.()}"
  return name
while True:
  print("\nplease tell me:")
  print("enter 'q' to stop!")
  first=input("first name:")
  if first=='q':
    break
  last=input("last name:")
  if last=='q':
    break
  f_name=get_name(first,last)
  print(f"hello {f_name}!")

7.4 传递列表

将列表传递给函数

def get(names):
  for name in names:
    index=f"hello,{name.title()}"
    print(index)
users=['jack','smith','kyle']
get(users)
#结果是
hello Jack!
hello Smith!
hello Kyle!

7.4.1在函数中修改列表

可以定义一个函数，形参是两个列表，然后在函数中进行列表的元素转移等等操作，用户只需要在调用函数时传递两个实参列表就行，即需要进行这种操作时，调用这个函数即可！

7.4.2 禁止函数修改列表

如果两个列表转移元素，但起始列表元素不能删除，可以把该列表的副本当作实参传递给函数，而不是该列表本身

index(my_name[:],friend_name)

传入my_name列表的副本

7.5传递任意数量的实参

预先不知道函数需要多少个实参，使用 *变量名，如 *name让python创建一个名为name的空元组，将实参封装到一个元组中。

def get(*names):
  for name in name:
    print(name)
get('jack','smith')#任意数量实参
#结果是
jack
smith

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

def get(size,*toppings):
  print(f"{size}:")
  for topping in toppings:
    print(topping)
get(16,'a','b')
get(15,'s'.'d','f')
#结果是
16:
a
b
15:
s
d
f

7.5.2使用任意数量的关键字实参

def get(first,last,**user_info):
  user['first_name']=first
  user['last_name']=last
  return(user)
people=get('smith','jack',sex='man',year='16')
print(people)
#结果是
{'first_name':'smith','last_name'='jack','sex'='man','year'=16}

7.6 将函数存储在模块中

使用函数的优点之一就是将代码块与主程序分离。我们还可以将函数存储在称为模块的独立文件中，再将模块导入到主程序中，import语句允许当前运行程序文件中使用模块中的代码

7.6.1导入整个模块

首先创建模块，模块是拓展名为.py的文件，包含要导入程序中的代码
创建一个name.py文件，再其所在目录创建一个名为make.py文件
再name.py文件中声明函数，在导入到make.py文件中

import name

name.function()#使用模块的函数

7.6.2导入特定的函数

可以导入某个模板中特定的函数

from name import function1
...
from name import function1,function2

7.6.3使用as给函数指定别名

如果要导入的函数名与该程序内函数名冲突，可以在调用时给函数指定别名，利用as

from name import function as md

md()#使用别名即可

7.6.4使用as给模块指定别名

import name as nm

nm.function()#模块名称使用别名即可

7.6.5导入模块中的所有函数

from name import *

导入模块name.py文件中的所有函数

第八章 类

8.1创造和使用类

根据类来创建对象称为实例化（面向对象编程）

8.1.1创建Dog类

每个类存储名字和年龄，赋予每条小狗蹲下和打滚的能力;
首字母大写的名称指的时类，定义时没有圆括号。
类中的函数称为方法。init()是一个特殊的函数，当根据类创建实例时，都会运行它。其中包含三个形参self,name,age。age的必不可少的，位置必须在其他形参的前面。
带有self前缀的变量可供类中所有方法使用
最有定义sit方法，这里只是打印一句话，在游戏中，可以时据以的蹲下动作的代码。

class Dog:
    def _init_(self,name,age):
      self.name = name
      self.age = age
    def sit(self):
      print(f"{self.name} is sitting.")

8.1.2 根据类创建实例

my_dog=Dog('smith',6)
print(f"my dog's name is {my_dog.name}")
print(f"my dog's age is {my_dog.age}")
#结果是
my dog's name is smith
my dog's age is 6

#访问属性
my_dog.name
#调用方法
my_dog.sit() 

8.2使用类和实例

8.2.1给属性指定默认值

class Dog:
    def _init_(self,name,age):
      self.name = name
      self.age = age
      self.size = mid
    def read_dog(self):
      print(f"my dog size is {self.size}")
my_dog=Dog('smith',6)
my_dog.read_dog()
#结果是
my dog size is mid

8.2.2修改属性的值

直接修改

my_dog.size = small

通过方法修改

class Dog:
  ----
  def change(self,size):
    self.size = size
my_dog=Dog('smith',6)
my_dog.change('small')

8.3继承

编写类时，并非都要从空白开始。如果要编写的类是已经存在的类的特殊类，可以使用继承，一个类继承另一个类时，将自动获得另一个类的属性和方法，原有的类为父类，新的类是子类。

8.3.1子类的方法_init_()

在既有类的基础上编写新类时，通常要调用父类的方法_init_()。这将初始化在父类_init_()中定义的所有属性，从而让子类包含这些属性
创建子类时，父类必须包含在当前文件中，且位于子类的前面，定义子类时，必须在()中指定父类的名称。
super()方法是一个特殊的函数，让你能够调用父类的方法

class Dog:
    def _init_(self,name,age):
      self.name = name
      self.age = age
      self.size = mid
class Taidi(Dog):
    def _init_(self,name,age):
      super()._init_(name,age)
my_dog=Taidi('huahua',20)

8.3.2给子类定义属性和方法

子类的属性和方法的定义形式与父类定义形式一样

8.3.3重写父类的方法

当父类的方法不适用所继承的子类时，可以重新定义该方法，Python将忽略父类的该方法，而使用子类中新的定义。

8.3.4将实例用作属性

如果一个类的细节很多，我们可以将其分成许多不同部分的小类

class Move:
   def _init_(self,name,age):
   
   def action(self):
      print = (f"{name} is {age} years old!")
      
      
class Dog:
    def _init_(self,name,age):
      self.name = name
      self.age = age
      self.size = mid
      self.move = Move() #将动作单独作为一个类
my_dog=Taidi('huahua',20)
Taidi.move.action()   #调用单独类中的方法

8.4导入类

将类存储在模板中，然后在主程序中导入所需的模板，使得主程序更为简洁

8.4.1 导入单个类

from car import Dog
# 导入一个名叫car的模板中的Car类

8.4.2在一个模板中存储多个类

一个模板中可以声明多个类

from car import Dog,Car

从模板中导入两个类

import car

也可以直接导入整个模板

8.4.3导入模板中的所有类

from car import *

导入car模板重的所有类

8.4.4使用别名

from car import Dog as EC

给Dog类用另一个简易的名称代替

第九章

9.1从文件中读取数据

with open('ab.txt') as file1
    contents = file1.read()
print(contents)

使用文件，首先都要打开文件，函数open（）接受一个参数，要打开的文件名称，返回一个表示文件的对象。有了表示对象后，使用方法read（）读取这个文件的内容

9.1.2文件途径

上述将简单的文件名传递给open()时，Python将在所执行文件目录中查找。
所以需要使用相对路径来表示文件的位置。

with open('text_files/filesname.txt') as ...

表示在所执行文件目录的子文件夹text.files文件中寻找文本文件，同时也可以使用绝对路径，方法相同，如果绝对路径太长，可以将其赋予给某个变量，将改变量传递给open函数。

9.1.3逐行读取

with open ('files.txt') as object:
	for line in object:
		print(line)

执行循环来遍历文件中的每一行，但打印结果可能会出现很多空白行，因为在某些文件中，每行的末尾都有一个看不见的换行符，而函数调用print()也会加上一个换行符，因此每行末尾都有两个换行符，要想消除这些换行符，需要使用rstrip()

9.1.4创建一个包含文件各行内容的列表

with open('fileaname.txt') as object:
	lines = object.readlines()
for line in lines:
	print(line.rstrip())

上述代码中readlines方法从文件中读取每一行，将其存储在一个列表中。
读取文件时，Python将所有文本都解读为字符串，如果读的是数，就需要使用int()或float()转换为数值

9.2写入文件

with open('files.txt','w') as object；
	object.write("i like python!")

给open函数传入两个实参，一个是要打开的文件名称，另一个是打开的模式——"w"表示写入模式，“a”表示附加模式，“r+”表示读写模式，如果省略模式实参，则默认为只读模式打开，如果要写入的文件不存在，将自动创建它
写入模式：清除已有内容，写入新内容。
附加模式；保存已有内容，后面加上新内容，要注意换行。

9.3异常

9.3.1处理ZeroDivisionError异常

做除法运算时，当除数为0时，将报错，可以使用try-except

try:
	print(5/0)
except
	print("this is error by zero!")

如果try里的代码出现错误，将执行except中的代码，这样可以避免程序崩溃。

try:
	answer = print(5/2)
except:
	print("this is a error!")
else:
	print(answer)

如果没有错误，则执行else中的部分，这个形式用于由用户输入数字时，判断能否执行使用，避免报错。

9.3.2处理FileFoundError异常

如果打开一个文件，但该文件不存在，将会报这样的错误，避免此时程序崩溃，可以使用try－except形式。
如果不需要将异常告诉用户，希望程序在发生异常时保持静默：

try:
	with open.....
except:
	pass

这时如果找不到文件，也不会报错，自动忽略该部分代码

9.4存储数据

模块json可以将python简单的数据结构转储到文件中。

import json
numbers = [1,2,3,4,5]
with open('numbers.json','w') as f:
	json.dump(numbers,f)

上述代码将一个列表写入到一个JSON文件中。
也可以讲json文件中的数据读取出来：

import json
with open('numbers.json') as f:	
	numbers = json.load(f)
print(numbers)