Python3基础

基础知识

基本输出流：print(“Hello python world!”)

没有结束符，对大小写敏感，注释用#开头，多行注释可以用两段"""或者'''将注释包含起来。

1. 标准数据类型

1.1变量
message=”Hello world!”
print(message)

1.2字符串
在python中用引号括起来的都是字符串，其中引号可以是单引号也可以是双引号。
1)使用方法修改字符串的大小写

name="Ada lovelace"
print(name.title())
print(name.upper())
print(name.lower())

上述代码输出结果如下

2）合并字符串

a="我正在"
b="python"
c=a+"学习"+b
print(c)

上述代码输出结果如下

3）使用制表符来添加空白
转义字符同C语言
删除空白用的不多吧，用的时候百度吧
4）python字符串运算符

a="Hello"
b="World"
print("a + b 输出结果：", a + b)
print("a * 2 输出结果：", a * 2)
print("a[1] 输出结果：", a[1])
print("a[1:4] 输出结果：", a[1:4])
if( "H" in a) :
    print("H 在变量 a 中")
if( "M" not in a) :
    print("M 不在变量 a 中")
print (r'\n')		#使转义字符表达原来的意思
print (R'\n')

上述代码输出结果如下

5）字符串格式化（格式化符号同C语言）

print("我是%s，我是%d月份出生的!"%("小明",7))

上述代码输出结果如下：

1.3数字
python数字有整数，浮点数
1） 整数

2） 浮点数

3） 数字函数

4）数字类型转化
int(x)：将x转换为一个整数。
float(x)：将x转换到一个浮点数。
complex(x)：将x转换到一个复数，实数部分为x，虚数部分为0。
complex(x,y)：将x和y转换到一个复数，实数部分为x，虚数部分为y。x和y是数字表达式。
5） 使用函数str（）避免类型错误

这是一个类型错误，python不知道23是int变量还是字符2和3。
使用str()函数

1.4列表
把他类比C语言中的指针数组。
在python中，用方括号（[ ]）括起来表示列表，用逗号来分隔其中的元素。
1）输出列表中元素

language=["php","html","css","mysql","javascript"]
print(language)
for i in range(0,5):
	print(language[i])
print(language[1:3])

上述代码输出结果如下：

修改字符串大小写同样适用于列表。
2）修改添加和删除列表中的元素

• 修改列表中的元素

language=["php","html","css","mysql","javascript"]
print(language)
language[0]="python"
print(language)

上述代码运行结果如下：

• 在列表中添加元素
  i）在列表末尾添加元素append()

language=["php","html","css","mysql","javascript"]
print(language)
language.append("python")
print(language)

ii)在列表中插入元素insert()

language=["php","html","css","mysql","javascript"]
print(language)
language.insert(1,"python")
print(language)

上述代码运行结果如下

第三行表示在索引1处添加了元素python。

• 从列表中删除元素
  i)使用del语句永久删除元素
  如果已经知道要删除的元素在列表中的位置

language=["php","html","css","mysql","javascript"]
print(language)
del language[0]
print(language)

上述代码运行结果如下：

ii)使用pop语句新建列表删除元素，依旧可以访问原表中的元素

language=["php","html","css","mysql","javascript"]
print(language)
poped_language=language.pop(3)
print(language)
print(poped_language)

pop可以删除任意位置的值不过不加数值默认为-1。

iii)我们还可以根据元素值用remove来删除

language=["php","html","css","mysql","javascript"]
print(language)
removed_language=language.remove('css')
print(language)
print(poped_language)

上述代码运行结果如下：

3）组织列表

• 使用sort()方法对列表进行永久性排序

language=["php","html","css","mysql","javascript"]
language.sort()
print(language)
language.sort(reverse=True)
print(language)

当在sort方法中加入reverse=True时将会倒序排列

• 使用sorted()方法对列表进行临时排序

language=["php","html","css","mysql","javascript"]
print(sorted(language))
print(language)

• 倒着打印列表（与原列表顺序相反）

language=["php","html","css","mysql","javascript"]
print(language)
language.reverse()
print(language)

• 确定列表的长度

language=["php","html","css","mysql","javascript"]
len(language)

4）脚本操作符

5）嵌套列表

a = ['a', 'b', 'c']
n = [1, 2, 3]
x = [a, n]
print(x)
print(x[0])
print(x[1])

6）列表的其他函数和方法

	max(list)：返回列表的最大值
	min(list)：返回列表的最小值
	list(seq)：将元组转化为列表
	list.count(obj)：统计某个元素在列表中出现的次数
	list.extend(seq)：一次性在列表末尾追加多个元素
	list.index(obj)：从列表中找出某个值第一个匹配项的索引位置
	list.insert(index, obj)：将对象插入列表
	list.clear()：清空列表
	list.copy()：复制列表

1.5元组
元组看起来犹如列表，不同的是元组中的值无法修改，并且元组使用小括号，列表使用方括号。

tuple=('1','2')
for a in tuple:
    print(a)

元组虽然不能修改其元素，但是能够重新定义元组

tuple=('1','2')
print("原元组为：")
for a in tuple:
    print(a)
tuple=('3','4')
print("修改后元组为：")
for b in tuple:
    print(b)

1.6字典（有点像结构体，但是很多不同之处）
1）基本用法如下：

dictionary={key1:value1,key2:value2}

字典由键-值组成，其中键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行。
此外，不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住。
2）访问字典中的值

alien={'color':'green','points':5}
print(alien['color'])
print(alien)

上述代码运行结果：

3）添加、修改、删除字典中的值

alien={'color':'green','points':5}
a=str(alien)#输出字典
print("字典原有键值"+a)
alien['x_position']=0
alien['y_position']=25

alien['color']='red'

del alien['points']

b=str(alien)
print("字典现在键值"+b)

1.7集合
集合（set）是一个无序的不重复元素序列。

可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

创建格式：

parame = {value01,value02,...}
或者
set(value)

创建集合：

a=set('abcdabcd')
print(a)
b={'a','b','e','a','d','b'}
print(b)

1）集合运算：

a=set('abcdabcd')
print(a)
b={'a','b','e','a','d','b'}
print(b)
print(a-b)#集合a中包含而集合b中不包含的元素
print(a|b)#集合a和b中的所有元素
print(a&b)#集合a和b都包含的元素
print(a^b)#不同时包含于a和b中的元素

2）增加、删除集合元素
增加元素语法格式如下：

s.add(value1)

还有一个方法，也可以添加元素，且参数可以是列表，元组，字典等，语法格式如下：

s.update(value1,value2,...)

a=set('abcdabcd')
b=list(range(1,5,2))
a.add('123')
print(a)
a.update(b,[9,8],{'z','x'})
print(a)

移除元素：
语法格式如下：
将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误。

s.remove(value)

此外还有一个方法也是移除集合中的元素，且如果元素不存在，不会发生错误。格式如下所示：

s.discard(value)

我们也可以设置随机删除集合中的一个元素，语法格式如下：

s.pop() 

但是在交互模式下，会固定删除第一个元素

a=set('abcdabcd')
b=a.pop()
print(b)
print(a)

3）其他操作

2.操作列表

首先先写一个注意的地方，python每条语句自动给你增加换行符，刚开始我觉得还非常方便，不需要自己打，但是发现有时需要两条语句在同一行，如果要实现不换行需要在变量末尾加上 end=""。

x="a"
y="b"
# 换行输出
print( x )
print( y )
 
print('---------')
# 不换行输出
print( x, end=" " )
print( y, end=" " )
print()

2.1遍历整个列表

languages=["php","html","css","mysql","javascript"]
for language in languages:
    print(language)

上述代码运行结果：

python最具特色的就是使用缩进来表示代码块，不需要使用大括号 {} 。

缩进的空格数是可变的，但是同一个代码块的语句必须包含相同的缩进空格数。
例如：

languages=['php','MySql','javascript','html']
for language in languages:
    print(language)
    print("是我自学的\n")
print("还要自学python")

运行结果：

2.2数值列表
1）使用函数range()

for value in range(1,5):
    print(value)

上述代码打印的不是1到5，而是1到4.

2）创建数字列表
如果将range()作为list的一个参数，输出将会为一个数字列表。

numbers=list(range(1,5))
print(numbers)

使用函数range还可以指定步长：

numbers=list(range(1,11,2))
print(numbers)

还可以进行乘方操作

squares=[]
for value in range(1,11):
    square=value**2
    squares.append(square)
print(squares)

列表解析
上面例子的几行代码等效于

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

首先指定一个描述性的列表名，指定左方括号，定义一个表达式，用于生成你要储存到列表中的值。在这个示例中，表达式为value**2。接下来，编写一个for循环，用于给表达式提供值，再加上右方括号。
2.3使用列表的一部分
1）切片

list=[......]
print(list[a:b])

a是起始索引，从第a-1个开始。没有指定起始索引，Python从列表开头提取
b是终止索引，到第b个结束。没有指定终止索引，将会终止与列表尾。
还可以倒序输出

list=[......]
print(list[-a:])

将会输出列表倒数a个值。
2）遍历切片
如果要遍历列表的部分元素，可在for循环中使用切片。

players=['a','b','c','d','e']

print("Here is the first three players")
for player in players[0:3]:
    print(player.title())

3）复制列表

number=list(range(1,11,2))
number_copy=number[0:3]
number_same=number
number.append(20)
number_copy.append(30)
number_same.append(40)
print(number)
print(number_copy)
print(number_same)

可以看出，当不使用切片时，number和number_same指向的是同一个列表。

3.if语句

包含 if语句，if-else语句，if-elif-else语句。
and（并）、or（或）、in（在…中）、not in（不在…中）、==（判断相等）、！=（不相等）

if-elif-else语句举例。

numbers=list(range(1,15,3))

for number in numbers:
    if number%2==0:
        print(str(number)+"is an even number!")
    elif number%2==1:
        print(str(number)+"is an odd number!")
    else:
        print(str(number)+"is a decimal!")
        #上一行只是凑例子的，发现range()不能加float类型，当然可以用函数重写一个式子

and，in，not in 举例：

布尔表达式。
True和False。（特别注意大小写）

使用多个列表。

# use multiple list
number_a=list(range(1,15,2))
number_b=list(range(1,15,3))
b=0
for a in number_a:
    if a in number_b:
        print(str(a)+" is in both lists!")
    else:
        b+=1
print(str(b)+" values are not in list b!")

4.操作字典

1.遍历字典
遍历字典中的键-值对。

user_0={
    'username':'abc',
    'first':'def',
    'last':'gh',}
for k,v in user_0.items():
    print('\nkey:'+k)
    print('value:'+v)

首先指定两个变量，k,v。然后在字典内，方法为items()，items可以返回一个键值对列表。
遍历字典中的所有键。方法为keys()。

user_0={
    'username':'abc',
    'first':'def',
    'last':'gh',}
for keys in user_0.keys():
    print(keys)

可以按顺序遍历所有键。方法为sorted()临时排序。

user_0={
    'username':'abc',
    'first':'def',
    'last':'gh',}
for keys in sorted(user_0.keys()):
    print(keys)

遍历字典中的所有值。方法为values()。

user_0={
    'a':'abc',
    'b':'def',
    'c':'gh',
    'd':'abc'}
for value in user_0.values():
    print(value)

当值很多时，我们希望去掉重复值。可使用集合set()。

user_0={
    'a':'abc',
    'b':'def',
    'c':'gh',
    'd':'abc'}
for value in set(user_0.values()):
    print(value)

2.嵌套

alien_0={'color':'green','point':5}
alien_1={'color':'yellow','point':10}
alien_2={'color':'red','point':15}

aliens=[alien_0,alien_1,alien_2]
for alien in aliens:
    print(alien)

#创建一个空的列表
aliens=[]

#创建30个绿色的外星人
for alien_number in range(30):
    new_alien = {'color':'green','point':5,'speed':'slow'}
    aliens.append(new_alien)
for alien in aliens[0:5]:
    print(alien)
print()
print(str(len(aliens)))


for alien in aliens[0:3]:
    if alien['color']=='green':
        alien['color']='yellow'
        alien['speed']='medium'
        alien['point']=10

for alien in aliens[0:5]:
    print(alien)

在字典中储存列表

#储存所点披萨的信息
pizza={
    'crust':'thick',
    'toppings':['mushroom','extra cheese'],
    }

#概述你所点的披萨
print("You ordered a "+pizza['crust']+"-crust pizza"+
      "with the following toppings:")
for topping in pizza['toppings']:
    print(topping,end=" ")

在字典中储存字典

#,有点多，编程最重要的就是标点符号
users={
    'user_0':{
        'first':'a',
        'last':'b',
        'location':'c',
        },
    'user_1':{
        'first':'d',
        'last':'e',
        'location':'e',
        },
    }
for user,userinformation in users.items():
    print("\nUser:"+user)
    full_name=userinformation['first']+userinformation['last']
    print("\tusername"+full_name)
    print("\tlocation"+userinformation['location'])

5.用户输入和while循环

5.1input

message=input("Tell me something ,and I will tell back to you:")
print(message)

prompt="Tell me something !"
prompt+="\nAnd I will tell back to you:"
message=input(prompt)
print(message)

input输入一般被python解释为字符串，我们可以用int获取数值输入。

age=input("How old are you?")
print(int(age))

5.2while循环
python只有while循环，没有do…while。

sum=0
counter=1
while counter<=100:
    sum+=counter
    counter+=1
print(sum)

此外同其他语言，也有break结束循环和continue继续循环。

# Fibonacci series: 斐波纳契数列
# 两个元素的总和确定了下一个数
a, b = 0, 1
while b < 10:
    print(b)
    a, b = b, a+b

上面式子最后一行从等号右边开始执行，运算完成后赋值给左边变量。等价于：

m=b
n=a+b
a=b
b=n

5.3使用while循环处理列表和字典
1）在列表之间移动元素

#首先创建一个等待验证用户列表
#和一个用于储存已验证用户的空列表
unconfirmed_users=['alice','brian','candace']
confirmed_users=['lily']

#验证每个用户、直到没有未验证用户为止
#将每个经过验证的列表都移到已验证用户列表中
while unconfirmed_users:
    current_user=unconfirmed_users.pop()

    print("Verifying user: "+current_user.title())
    confirmed_users.append(current_user)

#显示所有以验证的用户
print("\nThe following users have been confirmed:")
for confirmed_user in confirmed_users:
    print(confirmed_user.title(),end=" ")

2）删除包含特定值的所有列表元素

pets=['dog','cat','fish','rabbit','cat','fish','rabbit']
print(pets)

while 'cat' in pets:
    pets.remove('cat')

print(pets)

3）使用用户输入来填充字典

responses={}

#设置一个标志，指出调查是否结束
flag=1

#提示被调查着调查内容
while flag:
    name=input("\nWhat`s your name?")
    response=input("Who is your favorate star?")

    #将被调查内容输入到字典中去
    responses[name]=response

    #看看是否还有人接受调查
    repeat=input("Is there anyone who want to answer?(yes/no)")
    if repeat =='no':
        flag=0

#输出字典
print(responses)

6.函数
6.1定义函数
一般格式如下：

def 函数名（参数列表）:
    函数体

def greet():
    print("Hello!")

greet()

同其他语言一样，python也需要注意实参，形参的区别，也可以在定义函数的时候给参数赋默认值。
位置实参必需要有正确顺序，而关键字（即实参形参名称一样）python会自动匹配。
ps:给函数定义默认值时，等号两边不要有空格。

def function_name(parameter_0,parameter_1='defalut value')

同样对于函数调用关键字实参，也应该遵循这种约定：

function_name(value_0,parameter_1='value')

def describe_pets(name,type='dog'):
    print("\nI have a ",type)
    print("\twhich its name is ",name)

describe_pets(type='cat',name='Jack')
describe_pets(name='Jhon')

6.2返回值
下面是菜鸟教程的，我觉得讲的很好。

可更改(mutable)与不可更改(immutable)对象
在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。

• 不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变a的值，相当于新生成了a。

• 可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。 python 函数的参数传递：

• 不可变类型：类似 c++ 的值传递，如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。

• 可变类型：类似 c++ 的引用传递，如 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响

1）让实参变成可选的

def getFull_name(first,last,middle=''):
    if middle:
        full_name=first+" "+middle+" "+last
    else:
        full_name=first+" "+last
    return full_name

full_name=getFull_name('jimi','hendrix')
print(full_name.title())
full_name=getFull_name('john','hooker','lee')
print(full_name.title())

以上例子middle为可选的话，必需位于形参最后加上=''
返回字典

def getFull_name(first,last):
    person={'first':first,'last':last}
    return person

a=getFull_name('jimi','hendrix')
print(a)

2）返回字典
函数可以返回任何类型的值，包括复杂的列表和字典等较复杂的数据结构
例如：

def build_person(first_name,last_name):
    """返回一个字典值，其中包含一个人的信息"""
    person={'first name':first_name,
            'last name':last_name,
            }
    return person

a=build_person('jimi','hendrix')
print(a)

3）集合使用函数和while循环
6.3传递列表

def greet_everyone(list):
    for guest in list:
        print("Hello "+guest.title()+"!")
    return

list=['a','b','c']
greet_everyone(list)

1）在函数中修改列表

#首先创建一个列表，其中包含一些要打印的设计
unprinted_designs=['iphone case','robot pendant','dodecahedron']
completed_models=[]

"""模拟打印每个设计，直到没有未打印的设计为止
打印每个设计后，都将其移到列表completed_models中"""

def print_models(unprinted_designs,completed_models):
    while unprinted_designs:
        current_design=unprinted_designs.pop()
    
        #模拟根据设计制作3D打印模型的过程
        print("Pringting model:"+current_design)
        completed_models.append(current_design)
    return
    
def show_completed_models(completed_models):
    print("\nThe following models are completed!")
    for completed_model in completed_models:
        print(completed_model)
    return
    
print_models(unprinted_designs,completed_models)
show_completed_models(completed_models)

2）禁止修改列表
有时候需要将列表的值传递给函数而又不希望修改列表。
法一：使用tuple(seq) 函数将列表转化为元组。缺点：无法使用列表函数。
法二：可以像下面的方式传递列表

function_name(list_name[:])

切片表示法[:]创建的副本。
如上面举例打印的函数希望列表unprinted_designs的值不被删除，将调用函数的语句改为：print——models(unprinted_designs[:],completed_models。
6.4
1）传递任意数量的实参

def make_pizza(*toppings):
    '''打印顾客点的所有配料'''
    print(toppings)
    return

make_pizza('pepperoni')
make_pizza('mushroom','green peppers','extra cheese')

*toppings中的星号让python创建一个名为toppings的元组，可以储存传来的值。
若是参数列表为不止有一个，则会把剩下的实参赋给*

def make_food(food,*toppings):
    '''打印顾客点的所有配料'''
    print(food,toppings)
    return

make_food('pizza','mushroom','green peppers','extra cheese')

2）传递任意数量的关键字实参
形参列表有两个星号（*）时，参数会以字典一样的形式导入。

def build_profile(first,last,**user_info):
    '''创建一个字典，其中包含我们知道的有关用户的一切信息'''
    profile={}
    profile['first name']=first
    profile['last name']=last
    for key,value in user_info.items():
        profile[key]=value
    return profile

user_profile=build_profile('albert','einstein',
                           location='princeton',
                            field='physics')
for keys,values in user_profile.items():
    print(keys+":"+values)

ps:匿名函数不看了，和JavaScript的构造函数差不多，用的不多。
6.5将函数存储在模块中
（相当于C语言的库文件）
1）导入整个模块

import file

使用模块中的函数

file.function()

首先我们创建一个制作pizza.py文件，里面包含函数making_pizza

def make_pizza(size,*toppings):
    '''概述要制作的pizza'''
    print("\nMaking a "+str(size)+
          "-inch pizza with the following toppings")
    for topping in toppings:
        print("-"+topping)

然后新建一个making_pizza.py文件，和pizza.py文件在同一个目录下。

import pizza
pizza.make_pizza(16,'mushroom','green pepper','extra cheese')

导入刚才创建的文件。

2）导入特定的函数

from file import function_1,function_2,function_3...

使用导入的函数

function()

例如上例修改

from pizza import make_pizza
make_pizza(16,'mushroom','green pepper','extra cheese')

同样的结果。
3）使用as给模块指定别名

import file as alias

可以简化许多代码，上例

import pizza as p
p.make_pizza(16,'mushroom','green pepper','extra cheese')

4）使用as为函数创建别名
如果导入的函数和本文件中的函数重名的话，可以这样做。

from file import function as alias

例如制作pizza

from pizza import make_pizza as mp
mp(16,'mushroom','green pepper','extra cheese')

5）导入模块中的所有函数

from file import *

例如制作pizza

from pizza import *
make_pizza(16,'mushroom','green pepper','extra cheese')

6.6变量作用域（引用菜鸟教程）

Python 中，程序的变量并不是在哪个位置都可以访问的，访问权限决定于这个变量是在哪里赋值的。

变量的作用域决定了在哪一部分程序可以访问哪个特定的变量名称。Python的作用域一共有4种，分别是：

• L （Local） 局部作用域
• E （Enclosing） 闭包函数外的函数中
• G （Global） 全局作用域
• B （Built-in） 内置作用域（内置函数所在模块的范围） 以 L –> E –> G –>B 的规则查找，即：在局部找不到，便会去局部外的局部找（例如闭包），再找不到就会去全局找，再者去内置中找。

g_count = 0  # 全局作用域
def outer():
    o_count = 1  # 闭包函数外的函数中
    def inner():
        i_count = 2  # 局部作用域

内置作用域是通过一个名为 builtin
的标准模块来实现的，但是这个变量名自身并没有放入内置作用域内，所以必须导入这个文件才能够使用它。在Python3.0中，可以使用以下的代码来查看到底预定义了哪些变量:

 import builtins
 dir(builtins)

Python 中只有模块（module），类（class）以及函数（def、lambda）才会引入新的作用域，其它的代码块（如
if/elif/else/、try/except、for/while等）是不会引入新的作用域的，也就是说这些语句内定义的变量，外部也可以访问，如下代码：

>>> if True:
...  msg = 'I am from Runoob'
... 
>>> msg
'I am from Runoob'
>>> 

实例中 msg 变量定义在 if 语句块中，但外部还是可以访问的。

如果将 msg 定义在函数中，则它就是局部变量，外部不能访问：

>>> def test():
...     msg_inner = 'I am from Runoob'
... 
>>> msg_inner
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'msg_inner' is not defined
>>> 

从报错的信息上看，说明了 msg_inner 未定义，无法使用，因为它是局部变量，只有在函数内可以使用。

全局变量和局部变量 定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。

局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。调用函数时，所有在函数内声明的变量名称都将被加入到作用域中。如下实例：

#!/usr/bin/python3
 
total = 0 # 这是一个全局变量
# 可写函数说明
def sum( arg1, arg2 ):
    #返回2个参数的和."
    total = arg1 + arg2 # total在这里是局部变量.
    print ("函数内是局部变量 : ", total)
    return total
 
#调用sum函数
sum( 10, 20 )
print ("函数外是全局变量 : ", total)

当内部作用域想修改外部作用域的变量时，就要用到global和nonlocal关键字了。

以下实例修改全局变量 num：

#!/usr/bin/python3
 
num = 1
def fun1():
    global num  # 需要使用 global 关键字声明
    print(num) 
    num = 123
    print(num)
fun1()
print(num)

如果要修改嵌套作用域（enclosing 作用域，外层非全局作用域）中的变量则需要 nonlocal 关键字了，如下实例：

#!/usr/bin/python3
 
def outer():
    num = 10
    def inner():
        nonlocal num   # nonlocal关键字声明
        num = 100
        print(num)
    inner()
    print(num)
outer()

6.7函数内定义函数
在6.6中引用菜鸟教程中示例中，发现函数内可以定义函数，但是从网上没有搜到很好的教程，我买的书上也没讲，这里留疑。

7.类

7.1创建和使用类
1）创建类

class Dog():
    """Dog类"""
    instruction="This is a dog."
    def __init__(self,name,age):
        self.name=name
        self.age=age

    def sit(self):
        """对坐下命令的模拟"""
        print(self.name.title()+" is now sitting.")

    def roll_over(self):
        """对打滚命令的模拟"""
        print(self.name.title()+" rolled over")

在Python中，首字母大写的名称指的是类。
类中的函数称为方法，而方法__init__()是一个特殊的方法，当你根据Dog类创建新实例时，Python都会运行它。
我们上述方法__init__()定义中包含三个形参，形参self是必不可少的，还必须位于其他形参前面，Python在调用方法__init__()时都会自动传递实参self，他是一个指向实例本身的引用，我们在调用类时，不需要传递它，只需要给最后两个形参赋值即可。
（ps:self不是关键字，换成其他也可以，但是按照惯例我么使用self）
2）使用类

import Dog
my_dog=Dog.Dog('ABC',5)
print(my_dog.instruction)
print("My dog`s name is "+my_dog.name.title())
print("My dog is "+str(my_dog.age)+" years old.")
my_dog.sit()
my_dog.roll_over()

在上面我们创建了类Dog，现在我们把类导入，导入方法和函数一样

同函数，你可以反复调用此类，创建不同的实例。
7.2创建类和实例
1）给属性指定默认值

class Car():
    """模拟汽车"""
    def __init__(self,make,model,year):
        """初始化汽车信息"""
        self.make=make
        self.year=year
        self.model=model
        self.odometer=0

    def get_desc_name(self):
        """描述汽车信息"""
        desc_name=str(self.year)+" "+self.make+" "+self.model
        return desc_name.title()

    def read_odometer(self):
        """打印汽车里程消息"""
        print("This car has "+str(self.odometer)+" miles on it.")

my_car=Car('audi','a4',2016)
print(my_car.get_desc_name())
my_car.read_odometer()

2）修改属性
法一：直接修改属性的值

import car
my_car=car.Car('audi','a4',2016)
print(my_car.get_desc_name())
my_car.read_odometer()
my_car.odometer=23
my_car.read_odometer()

法二：通过方法修改属性的值
在类内定义另外的方法

class Car():
--snip--
    def update_odometer(self,mileage):
        """更新里程"""
        if mileage>=self.odometer:
            self.odometer=mileage
        else:
            print("You can`t roll back an odometer!")

调用

import car
my_car=car.Car('audi','a4',2016)
print(my_car.get_desc_name())
my_car.read_odometer()
my_car.update_odometer(46)
my_car.read_odometer()

法三、定义递增方法

class Car:
--snip--
    def incr(self,miles):
        self.odometer+=miles

调用：

import car
my_car=car.Car('audi','a4',2016)
print(my_car.get_desc_name())
my_car.read_odometer()
my_car.update_odometer(46)
my_car.incr(16)
my_car.read_odometer()

7.3继承
1）继承
前面我们创建了汽车的类，基于此我们创建一个电动汽车的类。

import car

class ElectriCar(car.Car):
    """电动汽车的独特之处"""
    def __init__(self,make,model,year):
        """初始化父类的属性"""
        super().__init__(make,model,year)

my_tesla=ElectriCar('tesla','model s',2016)
print(my_tesla.get_desc_name())

创建子类时，父类必需在子类前面（同文件或者导入都可以）。
子类中__init__接受创建Car实例所需要的信息。
super()是一个特殊函数，帮助父类和子类关联起来，让子类拥有父类所有属性。
2）重写父类
有时我们希望继承父类，但不是继承所有。
加入父类Car中含有一个fill_gas_tank()的方法，它对电动汽车来说毫无意义，因此我们可以在子类中重写这个方法，如果我们调用子类中的这个方法，父类的方法将会被忽略。
3）将实例用作属性

class Car():
--snip--

class Battery():
    """模拟电动汽车电瓶"""
    def __init__(self,battery_size=70):
        """初始化电瓶的属性"""
        self.battery_size=battery_size

    def desc_battery(self):
        """打印一条描述电瓶的消息"""
        print("This car has a "+str(self.battery_size)+"-kWh battery.")

class ElectriCar(Car):
    """电动汽车的独特之处"""
    def __init__(self,make,model,year):
        """初始化父类的属性"""
        super().__init__(make,model,year)
        self.battery=Battery()

my_tesla=ElectriCar('tesla','model s',2016)

print(my_tesla.get_desc_name())
my_tesla.battery.desc_battery()
"""调用类的类的方法"""

我们新建了一个Battery类，他没有继承任何新类，我们在创建ElectriCar时调用了它。,这看似做了很多额外工作，但现在我们可以多详细的描述电瓶都可以，不会使得ElectriCar变得混乱不堪。
7.4导入类和函数类似不过没有别名。
7.5类的私有方法

__private_method：两个下划线开头，声明该方法为私有方法，只能在类的内部调用 ，不能在类的外部调用。self.__private_methods。

7.6类的专有方法

7.7运算符重载

Python同样支持运算符重载，我们可以对类的专有方法进行重载，实例如下：

#!/usr/bin/python3
 
class Vector:
   def __init__(self, a, b):
      self.a = a
      self.b = b
 
   def __str__(self):
      return 'Vector (%d, %d)' % (self.a, self.b)
   
   def __add__(self,other):
      return Vector(self.a + other.a, self.b + other.b)
 
v1 = Vector(2,10)
v2 = Vector(5,-2)
print (v1 + v2)

8.文件和异常

ps:前面我以为很少用的知识发现在这有用。
方法rstrip():删除字符串后端的空白。
lstrip():删除字符串前端空白。
strip():删除字符串两端空白。

基本语法：（这一大块只是记录，实际不会用这么多，用于查阅。）

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

file: 必需，文件路径（相对或者绝对路径）。
mode: 可选，文件打开模式
buffering: 设置缓冲
encoding: 一般使用utf8
errors: 报错级别
newline: 区分换行符
closefd: 传入的file参数类型
opener:
mode 参数有：


默认为文本模式，如果要以二进制模式打开，加上 b 。

常用方式：

open(file, mode='r')

8.1从文件中读取数据

with open('pi.txt') as pi:
    contents=pi.read()
    print(contents)

详解：
关键字with在不再需要访问文件后将其关闭，我们使用了open()方法，但是没有使用close()；不建议使用open()+close()方式来处理文件，如果程序出现bug导致close()语句未执行，文件不会关闭，会丢失数据。使用with，Python会适时将其关闭。
据书上说read()方法到达文件末尾会返回一个空字符串，要删除空字符串，使用方法rstrip()将空白删除。即将最后一句改为print(contents.rstrip())
文件路径：分为相对路径和绝对路径
同HTML一样尽量使用相对路径，少使用绝对路径。（反斜杠（\））
现在我们不再将txt文本和pi.py放在同一个级别下。将txt文本放在pi2文件夹下，以pi.py为相对路径

那么读取时pi2\pi.txt
现在我们逐行读取：

file='pi2\pi.txt'

with open(file) as pi:
    for line in pi:
        print(line.rstrip())

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

file='pi2\pi.txt'

with open(file) as pi:
    lines=pi.readlines()
for line in lines:
    print(line.rstrip())

方法readlines()将从文件中读取每一行，并将其存储在一个列表中。该列表被存储在变量lines中；在with代码块外，我们依旧可以使用这个变量，那么你就可以在with代码块外使用这些内容。
8.2写入文件

file='text.txt'

with open(file,'w') as text:
    text.write("This is a text!\n")

模式w将会以写入模式操作文件（如果文件不存在，将会创建文件，如果文件存在，将会清空文件内容，要追加方式，用a）。
方法write()并不会自动在每行自动添加换行符，需要我们自己加入。
python读写文件都是字符串，如果要写入数字，先将数字用str()转化为字符串，如果要操作读取的数字，那么用int()或者float()转化为整形或者浮点型操作。
8.3异常
使用try-except代码块

try:
    print(5/0)
except ZeroDivisionError:			#注意缩进
        print("You can`t divide by zero!")

上述代码中，如果try代码块中的语句没有错误，那么将忽略except语句，否则核对错误类型是否为except后面的错误类型，如果是就执行except代码块中的语句。
一个except子句可以同时处理多个异常，这些异常将被放在一个括号里成为一个元组，例如:

except(RuntimeError, TypeError, NameError):
	pass

pass语句会让except什么也不做

else代码块（放置依赖于try代码块成功执行的代码）

print("Give me two numbers,and I will divide them!")
print("Enter 'q' to quit.")

while True:
    first=input("\nFirst number:")
    if first=='q':
        break
    second=input("Second number:")
    if second=='q':
        break
    try:
        answer=int(first)/int(second)
    except ZeroDivisionError:
        print("You can`t divide by 0!")
    except ValueError:
        print("You must print number!")
    else:
        print(answer)

8.4存储数据
1）使用json.dump()和json.load()（感觉是做开发必不可少的）
json.dump()用来存储数据，json.load()用来读入内存中的程序。

import json
numbers=[2,3,5,7,11,13]

file='number.json'
with open(file,'w') as f_obj:
    json.dump(numbers,f_obj)

with open(file) as read:
    number_2=json.load(read)

print(number_2)

先导入模块json

然后以写的方式打开文件，使用json.dump()将数字列表存储到文件number.json中。
然后我们以读的方式打开这个文件，然后使用json.load()读取存储的数据。

综合运用一下

import json

def get_stored_username():
	"""如果存储了用户名，就获取它"""
	file='user_name.json'
	try:
		with open(file) as read:
			username=json.load(read)
	except FileNotFoundError:
		return None
	else:
		return username

def get_new_username():
	"""获取新的用户名"""
	username=input("What`s your name?")
	file='user_name.json'
	with open(file,'w') as write:
		json.dump(username,write)
	return username
	
def greet_user():
	"""问候用户"""
	username=get_stored_username()
	if username:
		print("Welcome back,"+username+"!")
	else:
		username=get_new_username()
		print("I`ll remember you when you back,"+username+"!")
		
greet_user()

两次运行结果：