1.局部变量、全局变量

在函数内部修改全局变量时局部变量会创建一个和全局变量一样名称的局部变量，在更改的时候只会更改局部变量的值。
如果想要在函数内部修改全局变量需要给变量加上global关键字。

代码

>> count= 5
>>> def myFun():
 count = 10
 print(count)


>>> myFun()
10
>>> print (count)
5
>>> def myFun():
 global count
 count = 12
 print(count)


>>> myFun()
12
>>> print(count)
12

2.内嵌函数和闭包（closure）

python的函数支持内嵌，即在函数中定义函数

>>> def fun1():
    print('fun1 is being called')
    def fun2():
        print('fun2 is being called')
    fun2()


>>> fun1()
fun1 is being called
fun2 is being called

闭包（Closure）是词法闭包（Lexical Closure）的简称，是引用了自由变量的函数。这个被引用的自由变量将和这个函数一同存在，即使已经离开了创造它的环境也不例外。所以，有另一种说法认为闭包是由函数和与其相关的引用环境组合而成的实体。【光看文字说明比较难以理解】

>>> def funX():
    x = 3
    def funY():
        x *= x
        return x
    return funY()

>>> funX()
Traceback (most recent call last):
  File "<pyshell#33>", line 1, in <module>
    funX()
  File "<pyshell#32>", line 6, in funX
    return funY()
  File "<pyshell#32>", line 4, in funY
    x *= x
UnboundLocalError: local variable 'x' referenced before assignment

x对于funY（）来说是一个全局变量，因此funY（）中对x的调用被python shadowing保护了，在funY（）内创建了一个x的局部变量，所以x不能在赋值前被引用。

解决方法

• 1就是把外部变量的值储存在某种容器中（例如列表、元组等），因为容器不会被shadowing

>>> def funX():
    x = [3]
    def funY():
        x[0] *= x[0]
        return x[0]
    return funY()


>>> funX()
9

• 2在Python3中对此又做了改进，直接发明了一个nonlocal，用来声明内部函数中的变量不是局部变量

>>> def funX():
    x = 8
    def funY():
        nonlocal x
        x *=
        return x
    return funY()

>>> funX()
64

lambda函数

lambda作用：

• Python写一些执行脚本时，使用lambda就可以省下等一函数过程，比如说我们只是需要写个简单的脚本来管理服务器事件，我们就不需要专门定义一个函数然后再写调用，使用lambda就可以是的代码更加精简。
• 对于一些比较抽象的并且整个程序执行下来只需要调用一两次的函数么，有时候给函数起名也是比较头疼的问题，使用lambda就不许啊哟考虑命名的问题。
• 简化代码的可读性，由于普通的屌丝函数阅读经常要跳到开头def定义部分，使用lambda函数可以省去这样的步骤

#加法计算
>>> def add(x,y):
    return x+y

>>> add(3,4)
7
#lambda实现
>> lambda x,y :x + y
<function <lambda> at 0x11012a400>
>>> g = lambda x,y : x + y
>>> g(5,6)
11

filter函数

函数形式： filter(function or None, iterable) --> filter object
返回一个迭代器，该迭代器可以为该函数(项)进行迭代
|是正确的。如果函数是None，返回true的项。

>>>
#奇数
def odd(x):
       return x % 2

>>> temp = range(10)
>>> show = filter(odd,temp)
>>> list(show)
[1, 3, 5, 7, 9]

** lambda 结合filter实现奇数过滤器

>>> list(filter(lambda x : x % 2,range(10)))
[1, 3, 5, 7, 9]

map函数

函数形式：
map(func, * iterables) --> map object
函数功能：

• 对可迭代函数'iterable'中的每一个元素应用‘function’方法，将结果作为list返回。

>>> list(map(lambda x: x * 2, range(10)))
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

当索引不好用时㈠

>>> brand = ['xrk','lly','zmz','wqq','ymn','lkl']
>>> slogan = ['dream','beautiful','sunshine','dou','haha']
>>> print('lly is ',slogan[brand.index('lly')])
lly is  beautiful
>>>

字典映射

字符串型

 dict1 = {'xrk':'dream','lly':'beautiful','zmz':'lsunshine','ymn':'dou','lkl':'haha'}
>>> print('lly is',dict1['lly'])
lly is beautiful

浮点型

>>> dict2 = {1:'one',2:'two',3:'three'}
>>> dict2[2]
'two'
>>>

元组构成的字典

>>>
>>> dict3 = dict((('F',70),('i',105),('s',115),('C',67)))
>>> dict3
{'F': 70, 'i': 105, 's': 115, 'C': 67}

key + value方式创建数组

>>> dict4 = dict(zhanglei='congding change word',zhouJL='music change world')
>>> dict4
{'zhanglei': 'congding change word', 'zhouJL': 'music change world'}
>>>

更改

>>> dict4['zhouJL'] = 'coding change world'
>>> dict4
{'zhanglei': 'congding change word', 'zhouJL': 'coding change world'}

添加

>>> dict4['xrk'] = 'things will be ok'
>>> dict4
{'zhanglei': 'congding change word', 'zhouJL': 'coding change world', 'xrk': 'things will be ok'}

当索引不好用时㈡

fromekeys使用方法

>>> dict1.fromkeys((1,2,3))
{1: None, 2: None, 3: None}
>>> dict1.fromkeys((1,2,3),'Number')
{1: 'Number', 2: 'Number', 3: 'Number'}

key value items

>>> dict1 = dict1.fromkeys(range(32),'赞')
>>> dict1
{0: '赞', 1: '赞', 2: '赞', 3: '赞', 4: '赞'}
>>> for eachKey in dict1.keys():
    print(eachKey)


0
1
2
3
4

for eachValue in dict1.values():
    print(eachValue)


赞
赞
赞
赞
赞

for eachItem in dict1.items():
    print(eachItem)


(0, '赞')
(1, '赞')
(2, '赞')
(3, '赞')
(4, '赞')

判断字典对应键是否有值

>>> print(dict1[55])
Traceback (most recent call last):
  File "<pyshell#58>", line 1, in <module>
    print(dict1[55])
KeyError: 55
>>> dict1.get()
Traceback (most recent call last):
  File "<pyshell#59>", line 1, in <module>
    dict1.get()
TypeError: get expected at least 1 arguments, got 0
>>> dict1.get(77)
>>> print(dict1.get(77))
None
>>> dict1.get(66,'字典中不存在此项')
'字典中不存在此项'
>>>

不知道字典中是否有此键的时候（in 、 not in）

>>> 3 in dict1
True
>>> 88 in dict1
False
>>>

清空字典（clear）

>>> dict1
{0: '赞', 1: '赞', 2: '赞', 3: '赞', 4: '赞', 5: '赞', 6: '赞', 7: '赞', 8: '赞', 9: '赞', 10: '赞', 11: '赞', 12: '赞', 13: '赞', 14: '赞', 15: '赞', 16: '赞', 17: '赞', 18: '赞', 19: '赞', 20: '赞', 21: '赞', 22: '赞', 23: '赞', 24: '赞', 25: '赞', 26: '赞', 27: '赞', 28: '赞', 29: '赞', 30: '赞', 31: '赞'}
>>> dict1.clear()
>>> dict1
{}
>>>  

拷贝（这里是浅拷贝）copy

>>> a = {1:'one',2:'two',3:'three'}
>>> b = a
>>> c = a.copy
>>> id(a)
4523084896
>>> id(b)
4523084896
>>> id(c)
4522434776

>>> a = {1:'one',2:'two',3:'three'}
>>> c = a.copy()
>>> b = a
>>> b[4] = 'four'
>>> a
{1: 'one', 2: 'two', 3: 'three', 4: 'four'}
>>> b
{1: 'one', 2: 'two', 3: 'three', 4: 'four'}
>>> c
{1: 'one', 2: 'two', 3: 'three'}

pop pop

>>> a = {1:'one',2:'two',3:'three'}\
>>> a.pop(2)
'two'
>>> a.popitem()
(4, 'four')
>>> a
{1: 'one', 3: 'three'}
>>>

setdefault update

>>> a
{1: 'one', 3: 'three'}
>>> a.setdefault('真爱')
>>> a
{1: 'one', 3: 'three', '真爱': None}
>>> a.setdefault(5.'five')
SyntaxError: invalid syntax
>>> a.setdefault(5,'five')
'five'
>>> a
{1: 'one', 3: 'three', '真爱': None, 5: 'five'}
>>>

>>> b = {'真爱':'love'}
>>> a.update(b)
>>> a
{1: 'one', 3: 'three', '真爱': 'love', 5: 'five'}
>>>

集合

• 花括号不是字典的特权

>>> num = {}
>>> type(num)
<class 'dict'>
>>> num2 = {1,2,3,4,5}
>>> type(num2)
<class 'set'>
>>>

• 集合中的元素都是唯一的

>>> num2 = {1,2,3,4,5,5,4,3,2,1}
>>> num2
{1, 2, 3, 4, 5}

• 集合是无序的

>>> num2[2]
Traceback (most recent call last):
  File "<pyshell#106>", line 1, in <module>
    num2[2]
TypeError: 'set' object does not support indexing
>>>

如何创建集合

• 直接把一堆元素用花括号括起来
• 使用set()工厂函数

>>> set1 = set([1,2,3,4,5,5])
>>> set1
{1, 2, 3, 4, 5}
>>>

去掉列表中重复的元素的两种方法

• 非集合方式的实现

>>> num1 = [0,1,2,3,4,5,6,3,1]
>>> temp =[]
>>> for each in num1:
    if each not in temp:
        temp.append(each)


>>> temp
[0, 1, 2, 3, 4, 5, 6]
>>>

• 集合方式的实现()

>>> num1 = list(set(num1))
>>> num1
[0, 1, 2, 3, 4, 5, 6]
>>>

如何访问集合中的值

• 可以使用for把集合中的数据一个个读取出来
• 可以通过in和not in判断一个元素是否在集合中已经存在

>>> 1 in num2
True
>>> '1' in num2
False
>>>

add remove

>>> num2 = {1,2,3,4}
>>> num2.add(5)
>>> num2
{1, 2, 3, 4, 5}
>>> num2.remove(4)
>>> num2
{1, 2, 3, 5}
>>>

定义不可变集合

frozen：冰冻的，冻结的

>>> num3 = frozenset([1,2,3,4,5])
>>> num3.add(0)
Traceback (most recent call last):
  File "<pyshell#128>", line 1, in <module>
    num3.add(0)
AttributeError: 'frozenset' object has no attribute 'add'
>>>

文件处理

输入-> 处理-> 输出

Alt 文件
Alt

打开文件

File "/Users/zhanglei/PycharmProjects/untitled2/2.py", line 2
  import syssys.setdefaultencoding('utf-8')
                                  ^
SyntaxError: invalid syntax
解决方案如下

with open('/Users/zhanglei/Desktop/Book.txt', "r", encoding="utf-8") as f:
    read = f.read().splitlines()
    for row in read:
        print(row)

写入文件

with open('/Users/zhanglei/Desktop/Book123.txt', "w", encoding="utf-8") as f:
    read = f.write('wiiiiiiiiii')

python内置字符串方法

字符串大小写转换

• 首字母变大写
  str.capitalize()

• 将字符串转换成小写，其仅对 ASCII 编码的字母有效。
  str.lower()

• 将字符串转换成小写，Unicode 编码中凡是有对应的小写形式的，都会转换。
  str.casefold()

• 对字符串字母的大小写进行反转。
  str.swapcase()

将字符串所有字母变为大写，会自动忽略不可转成大写的字符。
str.upper()

字符串格式输出

• 将字符串按照给定的宽度居中显示，可以给定特定的字符填充多余的长度，如果指定的长度小于字符串长度，则返回原字符串
  str.center(width[, fillchar])

• 返回指定长度的字符串，字符串内容居左（右）如果长度小于字符串长度，则返回原始字符串，默认填充为 ASCII 空格，可指定填充的字符串。
  str.ljust(width[, fillchar]); str.rjust(width[, fillchar])

• 用 ‘0’ 填充字符串，并返回指定宽度的字符串
  str.zfill(width)

• 用指定的空格替代横向制表符，使得相邻字符串之间的间距保持在指定的空格数以内。
  str.expandtabs(tabsize=8)

• 类似 str.format(*args, **kwargs) ，不同的是 mapping 是一个字典对象。
  str.format_map(mapping)

字符串搜索定位

• 要搜索的字符、开始的索引号、截止的索引号。返回搜索个数
  str.count(sub[, start[, end]])
• 要搜索的字符、开始的索引号、截止的索引号。返回位置信息
  str.find(sub[, start[, end]]); str.rfind(sub[, start[, end]])

字符串的替换

需要替换的旧字符，新字符，替换个数。
str.replace(old, new[, count])

字符串的联合

用指定的字符串，连接元素为字符串的可迭代对象。
str.join(iterable)

>>> '-'.join(['1994','09','10'])
'1994-09-10'
>>>

>>> '-'.join([1993,1,10])
Traceback (most recent call last):
  File "<pyshell#190>", line 1, in <module>
    '-'.join([1993,1,10])
TypeError: sequence item 0: expected str instance, int found

partition()

参数
str : 指定的分隔符。
返回值
返回一个3元的元组，第一个为分隔符左边的子串，第二个为分隔符本身，第三个为分隔符右边的子串。
str.partition(str)

>>> str = "http://www.w3cschool.cc/"
>>> print(str.partition("://"))
('http', '://', 'www.w3cschool.cc/')

split()

参数
str -- 分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等。
num -- 分割次数。
返回值
返回分割后的字符串列表。
str.split(str="", num=string.count(str)).

>>> str = "zhanglei is a iOS developer"
>>> str.split(' ')
['zhanglei', 'is','a', 'iOS', 'developer']
>>> str.split(' ',1)
['zhanglei', 'is a iOS developer']
>>>

splitlines()

参数
keepends -- 在输出结果里是否去掉换行符('\r', '\r\n', \n')，默认为 False，不包含换行符，如果为 True，则保留换行符。
返回值
返回一个包含各行作为元素的列表。
str.splitlines([keepends])

str1 = 'ab c\n\nde fg\rkl\r\n'
print str1.splitlines();

str2 = 'ab c\n\nde fg\rkl\r\n'
print str2.splitlines(True)
以上实例输出结果如下：
['ab c', '', 'de fg', 'kl']
['ab c\n', '\n', 'de fg\r', 'kl\r\n']

writelines()

fileObject.writelines( [ str ])
参数
str -- 要写入文件的字符串序列。
返回值
该方法没有返回值。

>>> f = open('/Users/zhanglei/Desktop/ttt.txt','w')
>>> str = ['zhanglei','name']
>>> f.writelines(str)
>>> f.close()

永久存储：pickle模块

把python对象转化为二进制形式存放
对象 -> 二进制 pickling（存放）
二进制 -> 对象 unpicking（读取）

>>> import pickle
#存放
>>> mylist = [123,'zhanglei',['another list'],3.1222]
>>> pickle_file = open('/Users/zhanglei/Desktop/ttt.pkl')
>>> pickle_file = open('/Users/zhanglei/Desktop/ttt.pkl','wb')
>>> pickle.dump(mylist,pickle_file)
>>> pickle_file.close()
#读取
>>> pickle_file = open('/Users/zhanglei/Desktop/ttt.pkl','rb')
>>> my_list = pickle.load(pickle_file)
>>> print(my_list)
[123, 'zhanglei', ['another list'], 3.1222]
>>>

异常处理 Exception

异常检测try - except语句

try:
    检测范围
except Exception[as reason]:
    出现异常后的处理代码

>>> f = open('未知文件.txt')
Traceback (most recent call last):
  File "<pyshell#220>", line 1, in <module>
    f = open('未知文件.txt')
FileNotFoundError: [Errno 2] No such file or directory: '未知文件.txt'
>>> try :
    f = open('未知文件.txt')
    f.close()
except OSError:
    print('文件出错了')


文件出错了

封装、继承、多态

• 封装，也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。
• 使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。 继承现有类 + 扩展
• 允许将子类类型的指针赋值给父类类型的指针。
  实现多态，有二种方式，覆盖，重载。
  覆盖，是指子类重新定义父类的虚函数的做法。
  重载，是指允许存在多个同名函数，而这些函数的参数表不同（或许参数个数不同，或许参数类型不同，或许两者都不同）。

面向对象编程

Python魔法函数

__init__

只要实例化一个对象的时候，这个方法就会在这个对象被创建的时候自动被调用。

私有变量

在Python中定义私有变量只需要在变量名或函数名前加上‘__’两个下划线，那么这个函数或变量就会为私有的了。

class Person:
    name = 'zhanglei'

    
>>> p = Person()
>>> p.name
'zhanglei'
>>> class Person:
    __name = 'zhanglei'

    
>>> p = Person()
>>> p.name
Traceback (most recent call last):
  File "<pyshell#9>", line 1, in <module>
    p.name
AttributeError: 'Person' object has no attribute 'name'
>>> p.__name
Traceback (most recent call last):
  File "<pyshell#10>", line 1, in <module>
    p.__name
AttributeError: 'Person' object has no attribute '__name'
#伪私有
>>> p._Person__name
'zhanglei'
>>> 

继承

>>> class Parent:
    def hello(self):
        print('正在调用父类方法')

        
>>> class Child(Parent):
    pass

>>> p = Parent()
>>> p.hello()
正在调用父类方法
>>> c.hello()
正在调用父类方法
>>> 

注意:如果子类中定义与父类中同名的方法或属性，则会自动覆盖父类对应的方法和属性。

import random as r
class Fish:
    def __init__(self):
        self.x = r.randint(0,10)
        self.y = r.randint(0,10)
    def move(self):
        self.x -= 1
        print('现在的位置',self.x,self.y)

class Shark(Fish):
    def __init__(self):
        self.hungary = True
    def eat(self):
        if self.hungary:
            print('鱼以食为天')
            self.hungary = False
        else:
            print('吃撑了，不中了')


class Goldfish(Fish):
    pass

class Carp(Fish):
    pass

class Salmon(Fish):
    pass

fish = Fish()
fish.move()
goldfish = Goldfish()
goldfish.move()
shark = Shark()
shark.eat()
shark.eat()
shark.move()

下面是返回结果

/Library/Frameworks/Python.framework/Versions/3.5/bin/python3.5 /Users/zhanglei/PycharmProjects/untitled2/myEasygui.py
现在的位置 5 2
Traceback (most recent call last):
现在的位置 0 0
鱼以食为天
  File "/Users/zhanglei/PycharmProjects/untitled2/myEasygui.py", line 37, in <module>
吃撑了，不中了
    shark.move()
  File "/Users/zhanglei/PycharmProjects/untitled2/myEasygui.py", line 7, in move
    self.x -= 1
AttributeError: 'Shark' object has no attribute 'x'

Process finished with exit code 1

错误的解决方法(重写的方法中继承父类中的init方法)

• 调用未绑定的父类方法
• 使用super函数

def __init__(self):
    Fish.__init__(self)
    self.hungary = True

def __init__(self):
    super().__init__()
    self.hungary = True

python支持多重继承

>>> class Base1():
    def func1(self):
        print('Base1_func')

        
>>> class Base2():
    def func2(self):
        print('Base2_func')

        
>>> class C(Base1,Base2):
    pass

>>> c = C()
>>> c.func1
<bound method Base1.func1 of <__main__.C object at 0x107495780>>
>>> c.func1()
Base1_func
>>> c.func2()
Base2_func
>>> 

易产生不可预见的bug