python基本语法以及面向对象语法

1.基本语法

1.一个特殊的除法被称为地板除，对于地板除，得到的结果会忽略纯小数的部分，得到整数的部分，地板除使用//进行
2.如果要表示多行字符串，可以用’’’…’’‘表示。
3.r’…'表示法不能表示多行字符串，也不能表示包含’和 "的字符串
4.使用round保留小数点位数

num = 10 / 3
print(num) # ==> 3.3333333333333335
# 使用round保留两位小数
round(num, 2) # ==> 3.33

5.字符串format由两个部分组成，字符串模板和模板数据内容组成，通过大括号{}，就可以把模板数据内容嵌到字符串模板对应的位置。

1.# 字符串模板
template = 'Hello {}'
# 模板数据内容
world = 'World'
result = template.format(world)
print(result) # ==> Hello World
2.# 指定顺序
template = 'Hello {0}, Hello {1}, Hello {2}, Hello {3}.'
result = template.format('World', 'China', 'Beijing', 'imooc')
print(result) # ==> Hello World, Hello China, Hello Beijing, Hello imooc.
3.# 调整顺序
template = 'Hello {3}, Hello {2}, Hello {1}, Hello {0}.'
result = template.format('World', 'China', 'Beijing', 'imooc')
print(result) # ==> Hello imooc, Hello Beijing, Hello China, Hello World.
4.# 指定{}的名字w,c,b,i
template = 'Hello {w}, Hello {c}, Hello {b}, Hello {i}.'
world = 'World'
china = 'China'
beijing = 'Beijing'
imooc = 'imooc'
# 指定名字对应的模板数据内容
result = template.format(w = world, c = china, b = beijing, i = imooc)
print(result) # ==> Hello World, Hello China, Hello Beijing, Hello imooc.

6.字符切片

s = 'ABCDEFGHIJK'
abcd = s[0:4] # 取字符串s中的第一个字符到第五个字符，不包括第五个字符
print(abcd) # ==> ABCD
cdef = s[2:6] # 取字符串s中的第三个字符到第七个字符，不包括第七个字符
print(cdef) # ==> CDEF

注意：在Python规范中，一般使用4个空格作为缩进。
7.if语句

age = 1
if age >= 18:
    print('adult')
elif age >= 6:
    print ('teenager')
else:
    print ('baby')

8.for语句

s = 'ABCD'
for ch in s:
    print(ch) # 注意缩进

一定要注意缩进

L = [75, 92, 59, 68, 99]
sum = 0.0
for x in L:
    sum = sum + x
print(sum / 5)

9.while循环

1.
num = 0
sum = 0
while True:
    if num > 1000:
        break
    if num % 2 == 0:
        sum = sum + num
    num = num + 1
print(sum)
2.
num = 0
sum = 0
while num<1000:
    num =num+1
    if num%2==0:
        continue
    sum = sum + num
print(sum)

2.其它语法

容器：列表(list)、元组(tuple)、字典(dict)、集合(set)等，他们都可以放入多个元素，都可作是容器.

1.列表(list): 一种有序的容器，放入list中的元素，将会按照一定顺序排列，list可以同时放入任意类型的数据。

names = ['Alice', 'Bob', 'David', 'Ellena']
print(names[-1]) # ==> Ellena    #-1表示倒序

append()方法总是将元素添加到list的尾部。

names = ['Alice', 'Bob', 'David', 'Ellena']
names.append('Candy')
print(names) # ==> ['Alice', 'Bob', 'David', 'Ellena', 'Candy']

insert()方法需要两个参数，插入位置，以及插入元素。

names = ['Alice', 'Bob', 'David', 'Ellena']
names.insert(2, 'Candy')
print(names) # ==> ['Alice', 'Bob', 'Candy', 'David', 'Ellena']

pop()方法默认删除列表的最后一个元素，并返回，除可以删除最后一个元素以外，还可以接收一个参数，指定需要删除的元素的位置。

L = ['Alice', 'Bob', 'Candy', 'David', 'Ellena']
name = L.pop(2)
print(name) # ==> Candy
print(L) # ==> ['Alice', 'Bob', 'David', 'Ellena']

二维list

alice_scores = [100,89,92]
bob_scores = [70,65,81]
candy_scores = [88,72,77]
all_scores = [alice_scores, bob_scores, candy_scores]
score = all_scores[1][2] # ==> 81

2.元组(tuple)：一个有序容器，在元组中，同样可以包含0个或者多个元素，并且也支持索引访问、切片等操作。

注意：列表和元组之间可以相互转换。tuple和list不一样的是，tuple是固定不变的，一旦变成tuple，tuple中的每一个元素都不可被改变，同时也不能再往tuple中添加数据，而list是可以的。

T = ('Alice', 'Bob', 'Candy', 'David', 'Ellena')
print(T) # ==> ('Alice', 'Bob', 'Candy', 'David', 'Ellena')
L = list(T)
print(L) # ==> ['Alice', 'Bob', 'Candy', 'David', 'Ellena']

count()方法用来统计tuple中某个元素出现的次数。

T = (1, 1, 2, 2, 3, 3, 1, 3, 5, 7, 9)
print(T.count(1)) # ==> 3
print(T.count(10)) # ==> 0

index()方法可以返回指定元素的下标，当一个元素多次重复出现时，则返回第一次出现的下标位置。

T = (1, 1, 2, 2, 3, 3, 1, 3, 5, 7, 9)
T.index(9) # ==> 10
T.index(5) # ==> 8
T.index(1) # ==> 0 # 多次出现，返回第一次出现的位置

注意，index()方法和count()方法不一样，当指定的元素不存在时，使用index()方法Python会报错。

T = (1, )
print(T) # ==> (1, )   要定义只有一个元素的tuple，需要在元素后面添加一个逗号,。

T = (1, 'CH', [3, 4])
L = T[2]
print(L) # ==> [3, 4]
# 尝试替换L中的元素
L[1] = 40
print(L) # ==> [3, 40]
print(T) # ==> (1, 'CH', [3, 40])

T = (1, 'CH', [3, 4])
L2 = [3, 40]
# 尝试替换tuple中的list
T[2] = L2
# 报错

3.dict（字典）容器：花括号{}表示这是一个dict，然后key和value之间使用冒号:分割，并且每一组key:value的最后，以逗号,表示这一组的结束。
dict是可变的，我们随时可以往dict中添加新的key-value

d = {
    'Alice': 45,
    'Bob': 60
}
d = dict()
print(d) # ==> {}
if 'Alice' in d:
    print(d['Alice']) # ==> 45
if 'Dodo' in d: # Dodo不存在，所以不会走下面的逻辑
    print(d['Dodo'])
print(d.get('Alice')) # ==> 45
print(d.get('Dodo')) # ==> None

d = {
    'Alice': 45,
    'Bob': 60,
    'Candy': 75,
    'David': 86,
    'Ellena': 49
}
d['Mimi'] = [72, 73]
d['Dodo'] = [88, 90]
print(d)
d['Mimi'].append(75)
d['Dodo'].append(90)
print(d)
alice_score= d.pop('Alice')
print(alice_score) # ==> 45
print(d) # ==> {'Bob': 60, 'Candy': 75, 'David': 86, 'Ellena': 49}

赋值语句其实有两个功能：
当key不存在时，往dict中添加对应的key: value元素。
当key存在时，会更新dict，用新的value替换原来的value。

需要注意的是，pop()方法的参数是dict中的key，当key不存在时，同样会引起错误。

d = {
    'Alice': 45,
    'Bob': 60,
    'Candy': 75,
    'David': 86,
    'Ellena': 49
}
name = 'Aice'
if name in d.keys():
    d.pop(name)
else:
    print('{} not in d'.format(name))

Python遍历dict

d = {
    'Alice': 45,
    'Bob': 60,
    'Candy': 75,
    'David': 86,
    'Ellena': 49
}
d.clear() 
print(d) # ==> {}   #清除所有元素
keys = d.keys()
print(len(keys))    #输出d的元素个数
for key in d: # 遍历d的key
    value = d[key]
    if value > 60:
        print(key, value)
for key, value in d.items():
    if value > 60:
        print(key, value)
# ==> Candy 75
# ==> David 86

4.Set（集合）容器
set元素是不允许重复的，而list可以包含相同的元素；set与list的另一个区别是，set里面的元素是没有顺序的。
创建set的方式是使用set()，并传入一个list，list的元素将会被转换成set的元素。
set元素是区分大小写的

s = set([1, 4, 3, 2, 5, 4, 2, 3, 1])
print(s) # ==> set([1, 2, 3, 4, 5])

names = ['Alice', 'Bob', 'Candy', 'David', 'Ellena']
name_set = set(names)
name_set.add('Alice')
print(name_set) # ==> set(['Bob', 'Ellena', 'Alice', 'Candy', 'David'])
new_names = ['Hally', 'Isen', 'Jenny', 'Karl']
name_set = set(names)
name_set.update(new_names) # ==> set(['Jenny', 'Ellena', 'Alice', 'Candy', 'David', 'Hally', 'Bob', 'Isen', 'Karl'])
print(name_set)

set提供了remove()方法允许我们删除set中的元素。
需要注意的是，如果remove的元素不在set里面的话，那么将会引发错误。

L = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
S = set([1, 3, 5, 7, 9, 11])
for item in L:
    if item in S:
        S.remove(item)
    else:
        S.add(item)
print(S)

除remove()方法外，还使用discard()方法删除元素，并且，和remove()不同的是，当元素不存在时，使用discard()并不会引发错误，所以使用discard()是更加高效的一个方法。

name_set = set(['Jenny', 'Ellena', 'Alice', 'Candy', 'David', 'Hally', 'Bob', 'Isen', 'Karl'])
name_set.discard('Jenny')
print(name_set) # ==> set(['Ellena', 'Alice', 'Candy', 'David', 'Hally', 'Bob', 'Isen', 'Karl'])
name_set.discard('Jenny')
print(name_set) # ==> set(['Ellena', 'Alice', 'Candy', 'David', 'Hally', 'Bob', 'Isen', 'Karl']

set也提供了clear()方法，可以快速清除set中的所有元素。

name_set = set(['Jenny', 'Ellena', 'Alice', 'Candy', 'David', 'Hally', 'Bob', 'Isen', 'Karl'])
print(name_set) # ==> set(['Jenny', 'Ellena', 'Alice', 'Candy', 'David', 'Hally', 'Bob', 'Isen', 'Karl'])
name_set.clear()
print(name_set) # ==> set([])

集合的子集和超集

s1 = set([1, 2, 3, 4, 5])
s2 = set([1, 2, 3, 4, 5, 6, 7, 8, 9])
# 判断s1是否为s2的子集
s1.issubset(s2) # ==> True
# 判断s2是否为s1的超集
s2.issuperset(s1) # ==> True

判断集合是否重合(如果有重合，返回False，否则返回True。)

s1 = set([1, 2, 3, 4, 5])
s2 = set([1, 2, 3, 4, 5, 6, 7, 8, 9])
s1.isdisjoint(s2) # ==> False，因为有重复元素1、2、3、4、5

已知两个集合s1、s2，请判断两个集合是否有重合，如果有，请把重合的元素打印出来。

在s1 = set([1, 2, 3, 4, 6, 8, 10])
s2 = set([1, 2, 3, 4, 5, 6, 7, 8, 9])
flag = s1.isdisjoint(s2)
if not flag:
    for item in s1:
        if item not in s2:
            continue
        print(item)

5.函数

cmp(x, y)函数，x < y 返回 -1，x == y 返回0，x > y返回1。
int()函数可以将合法的其它类型数据转换为整数。
str()函数可以将其它类型的数据转换为字符串。
abs()函数接收一个参数，参数可以是整数，也可以是浮点数
isinstance()函数,可以判断参数类型，它接收两个参数，第一个是需要判断的参数，第二个是类型。

自定义函数 def

def list_sum(L):
    result = 0
    for num in L:
        result = result + num
    return result
L = [1, 3, 5, 7, 9, 11] 
result =list_sum(L)
print(result)
def square_of_sum(L):
    sum = 0
    for x in L:
        sum = sum + x * x
    return sum
print(square_of_sum([1, 2, 3, 4, 5]))
print(square_of_sum([-5, 0, 5, 15, 25]))
def sub_sum(L):
    index = 0
    sum1 = 0
    sum2 = 0
    for item in L:
        if index % 2 == 0:
            sum1 += item
        else:
            sum2 += item
        index += 1
    return sum1, sum2

L = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
result = sub_sum(L)
print('奇数项的和 = {}'.format(result[0]))
print('偶数项的和 = {}'.format(result[1]))

请分别使用循环和递归的形式定义函数，求出1~100的和。

def my_sumA(n):
    sum = 0
    index = 1
    while index <= n:
        sum += index
        index += 1
    return sum
print(my_sumA(10))
def my_sumB(n):
    sum = 0
    if n == 1:
        sum = n
    else:
        sum = n + my_sumB(n - 1)
    return sum
print(my_sumA(10))
计算 x 的N次方的函数:
def power(x, n):
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s

可变参数通常使用*args来表示

def func(*args):
    print('args length = {}, args = {}'.format(len(args), args))
func('a') # ==> args length = 1, args = ('a',)
func('a', 'b') # ==> args length = 2, args = ('a', 'b')
def average(*args):
    sum = 0.0
    for item in args:
        sum += item
    avg = sum / len(args)
    return avg
print(average(1, 2)) # ==> 1.5
print(average(1, 2, 2, 3, 4)) # ==> 2.4
print(average())  # 报错
修改后
def average(*args):
    sum = 0.0
    if len(args) == 0:
        return sum
    for item in args:
        sum += item
    avg = sum / len(args)
    return avg
print(average(1, 2)) # ==> 1.5
print(average(1, 2, 2, 3, 4)) # ==> 2.4
print(average())   # ==> 0.0

于可变关键字参数，一般使用**kwargs来表示。

def info(**kwargs):
    print('name: {}, gender: {}, age: {}'.format(kwargs.get('name'), kwargs.get('gender'), kwargs.get('age')))

info(name = 'Alice', gender = 'girl', age = 16)
def func(param1, param2, param3 = None, *args, **kwargs):
    print(param1)
    print(param2)
    print(param3)
    print(args)
    print(kwargs)

func(100, 200, 300, 400, 500, name = 'Alice', score = 100)
# ==> 100
# ==> 200
# ==> 300
# ==> (400, 500)
# ==> {'name': 'Alice', 'score': 100}

def info(**kwargs):
    names = kwargs['names']
    gender_list = kwargs['gender']
    age_list = kwargs['age']
    index = 0
    for name in names:
        gender = gender_list[index]
        age = age_list[index]
        print('name: {}, gender: {}, age: {}'.format(name, gender, age))
        index += 1

info(names = ['Alice', 'Bob', 'Candy'], gender = ['girl', 'boy', 'girl'], age = [16, 17, 15])

python的面向对象编程

1.class关键字定义一个类

class Person: pass
class Person(): pass
class Person(object): pass

2.创建实例使用类名+()，类似函数调用的形式创建：

class Person(object): pass
xiaohong = Person()
xiaoming = Person()

3.实例属性的定义

xiaohong.name = ‘xiaohong’
print(xiaohong.name)

class Animal(object):  pass 
dog = Animal() 
cat = Animal()
dog.name = "lucy"
dog.age = 2
cat.name = "ruby"
cat.age = 1
print(dog.name)
print(cat.age)

4.实例属性的初始化(init()方法被自动调用，__是两个下划线)

实例属性每个实例各自拥有，互相独立，而类属性有且只有一份

class Person(object):
    localtion = 'Asia'   #定义类属性   
    def __init__(self, name, sex, age):    #__init__() 方法的第一个参数必须是 self
        self.name = name
        self.sex = sex
        self.age = age
        self.localtion = localtion
        #在实例化的时候，需要提供除self以外的所有参数。
xiaoming = Person('Xiao Ming', 'boy', 13,beijing)
xiaohong = Person('Xiao Hong', 'girl', 14,shanghai)
print(xiaohong.name)
print(xiaohong.sex)
print(xiaohong.age)   
print(xiaohong.localtion)
print(Person.localtion)   # 类属性只有一次，也可以通过类名直接访问
Person.localtion = 'Africa'
print(xiaohong.localtion)
print(Person.localtion)          

类属性和实例属性同时存在，实例属性的优先级是要高于类属性的，在操作实例的时候，优先是操作实例的属性。
另外，当实例没有和类同名的时候，通过实例对象，依然可以访问到类属性。

5.私有属性是以双下划线’__'开头的属性。

在外部访问私有属性将会抛出异常，提示没有这个属性。 私有属性无法从外部访问，但是，从类的内部是可以访问的。

6.实例的方法指的就是在类中定义的函数，实例方法的第一个参数永远都是self

class Animal(object):
    def __init__(self, name, age, localtion):
        self.__name = name   #私有属性  
        self.age = age
        self.localtion = localtion
        
    def get_name(self):
        return self.__name
        
    def get_info(self):
        return ' age = {}, localtion = {}'.format(self.age, self.localtion)

dog = Animal('wangwang', 1, 'GuangDong')
print(dog.get_info())
print(dog.get_name())

name是实例的私有属性，从外部是无法访问的，而get_name(self) 就是一个实例方法，在实例方法里面是可以操作私有属性的，注意，它的第一个参数是self。
另外，init(self, name)其实也可看做是一个特殊的实例方法。
通过定义get_name(self)方法，在外部就可以通过这个方法访问私有属性了。

7.定义类方法 （添加 @classmethod）

class Animal(object):
    __localtion = 'Asia'
    def __init__(self, name, age):
        self.name = name
        self.age = age

    @classmethod
    def set_localtion(cls, localtion):
        cls.__localtion = localtion

    @classmethod
    def get_localtion(cls):
        return cls.__localtion

print(Animal.get_localtion()) # ==> Asia
Animal.set_localtion('Afica')
print(Animal.get_localtion()) # ==> Africa

和实例方法不同的是，这里有两点需要特别注意：
类方法需要使用@classmethod来标记为类方法，否则定义的还是实例方法
类方法的第一个参数将传入类本身，通常将参数名命名为 cls，上面的 cls.__localtion 实际上相当于Animal.__localtion。

python继承

1.继承

class Person(object):
    def __init__(self, name, gender):
        self.name = name
        self.gender = gender
class Student(Person):
    def __init__(self, name, gender, score):
        super(Student, self).__init__(name, gender)
        self.score = score
student = Student('Alice', 'girl', 100)
print(student.name) # ==> Alice
print(student.gender) # ==> girl
print(student.score) # ==> 100

在定义继承类的时候，有几点是需要注意的：
class Student()定义的时候，需要在括号内写明继承的类Person
在__init__()方法，需要调用super(Student, self).init(name, gender)，来初始化从父类继承过来的属性

2.isinstance()函数可以判断一个变量的类型。

class Person(object):
    def __init__(self, name, gender):
        self.name = name
        self.gender = gender

class Student(Person):
    def __init__(self, name, gender, score):
        super(Student, self).__init__(name, gender)
        self.score = score
p = Person('Tim', 'Male')
s = Student('Bob', 'Male', 88)
>>> isinstance(p, Person)
True # p是Person类型
>>> isinstance(p, Student)
False # p不是Student类型   
>>> isinstance(s, Person)
True # s是Person类型
>>> isinstance(s, Student)
True # s是Student类型
s = 'this is a string.'
n = 10
print(isinstance(s, str)) # ==> True
print(isinstance(n, str)) # ==> False

3.多态

class Person(object):
    def __init__(self, name, gender):
        self.name = name
        self.gender = gender
    def who(self):
        return 'I am a Person, my name is %s' % self.name

class Student(Person):
    def __init__(self, name, gender, score):
        super(Student, self).__init__(name, gender)
        self.score = score
    def who(self):
        return 'I am a Student, my name is %s' % self.name

class Teacher(Person):
    def __init__(self, name, gender, course):
        super(Teacher, self).__init__(name, gender)
        self.course = course
    def who(self):
        return 'I am a Teacher, my name is %s' % self.name
p = Person('Tim', 'Male')
s = Student('Bob', 'Male', 88)
t = Teacher('Alice', 'Female', 'English')
print(p.who())
print(s.who())
print(t.who())

从定义上来讲，Student和Teacher都拥有来自父类Person继承的who()方法，以及自己定义的who()方法。但是在实际调用的时候，会首先查找自身的定义，如果自身有定义，则优先使用自己定义的函数；如果没有定义，则顺着继承链向上找。

4.多重继承

class Person(object):
    pass
class Student(Person):
    pass
class Teacher(Person):
    pass
class SkillMixin(object):
    pass
class BasketballMixin(SkillMixin):
    def skill(self):
        return 'basketball'
class FootballMixin(SkillMixin):
    def skill(self):
        return 'football'
class BStudent(BasketballMixin, Student):
    pass
class FTeacher(FootballMixin, Teacher):
    pass
s = BStudent()
print(s.skill())
t = FTeacher()
print(t.skill())

5.type()函数：获得变量的类型
dir()方法：获取变量的所有属性
内建法：在dir列出的属性中，有很多是以下划线开头和结尾的，这些都是特殊的方法，称为内建方法
dir()返回的属性是字符串列表，如果已知一个属性名称，要获取或者设置对象的属性，用 getattr() 和 setattr( )函数了。

class Person(object):
    def __init__(self, name, gender, **kw):
        self.name = name
        self.gender = gender
        for k, v in kw.items():
            getattr(self, k, v)
            setattr(self, k, v)

p = Person('Bob', 'Male', age=18, course='Python')
n = 1
s = 'this is a string'
print(type(s))
print(dir(n))
print(dir(p))
print(p.age)
print(p.course)
getattr(p, 'name')
print(p.name)
setattr(p, 'name', 'Adam') 
print(p.name)

python特殊方法

1. __str()和__repr()方法

str()用于显示给用户，而__repr()用于显示给开发人员，当使用str()时，实际调用的是__str()方法，而直接输入变量，调用的是__repr__()方法。

l = [1,2,3,4,5]
print(str(l)) # ==> '[1, 2, 3, 4, 5]'
class Person(object):
    def __init__(self, name, gender):
        self.name = name
        self.gender = gender
    def __str__(self):
        return 'name: {}, gender: {}'.format(self.name, self.gender)
    def __repr__(self):
        return 'name: {}, gender: {}'.format(self.name, self.gender)

bob = Person('Bob', 'Male')
print(str(bob)) # ==> 'name: Bob, gender: Male'

2.__len__方法 (获取元素个数)

class Fib(object):     #斐波那契数列
    def __init__(self, num):
        self.res = []
        self.num = num
        a = 0
        b = 1
        for x in range(num):
            self.res.append(a)
            a, b = b, a + b
    def __str__(self):
        return str(self.res)

    def __len__(self):
        return self.num
f = Fib(10)
print(f)
print(len(f))

3.add、sub、mul、__truediv__方法

地板除的特殊方法是__floordiv__，普通除法是__truediv__,地板除法的结果只会向下取整数。

def gcd(a, b):
    if b == 0:
        return a
    return gcd(b, a % b)
class Rational(object):
    def __init__(self, p, q):
        self.p = p
        self.q = q
    def __add__(self, r):
        return Rational(self.p * r.q + self.q * r.p, self.q * r.q)
    def __sub__(self, r):
        return Rational(self.p * r.q - self.q * r.p, self.q * r.q)
    def __mul__(self, r):
        return Rational(self.p * r.p, self.q * r.q)
    def __truediv__(self, r):
        return Rational(self.p * r.q, self.q * r.p)
    def __str__(self):
        g = gcd(self.p, self.q)
        return '{}/{}'.format(int(self.p/g), int(self.q/g))
r1 = Rational(1, 2)
r2 = Rational(1, 5)
print(r1 + r2)
print(r1 - r2)
print(r1 * r2)
print(r1 / r2)

4.__slots__方法

限制当前类所能拥有的属性，避免因为外部属性的操作导致类属性越来越难以管理。

class Person(object):
    __slots__ = ('name', 'gender')
    def __init__(self, name, gender):
        self.name = name
        self.gender = gender
class Student(Person):
    __slots__ = ('score',)
    def __init__(self, name, gender, score):
        self.name = name
        self.gender = gender
        self.score = score
s = Student('Bob', 'male', 59)
s.name = 'Tim'
s.score = 99  
print(s.score)
print(s.name)

5.__call__方法

把一个类实例也变成一个可调用对象，可以实现一个特殊的方法__call__()

class Person(object):
    def __init__(self, name, gender):
        self.name = name
        self.gender = gender

    def __call__(self, friend):
        print('My name is {}...'.format(self.name))
        print('My friend is {}...'.format(friend))
p = Person('Bob', 'Male')
p('Alice')  # ==> 用函数的方式调用Person类的实例p

class Fib(object):
    def __init__(self):
        self.res = []
    def __call__(self, num):
        a = 0
        b = 1
        for x in range(num):
            self.res.append(a)
            a, b = b, a + b
        return self.res
f = Fib()
print(f(10))

python模块

1.python模块

数学模块math、cmath、decimal、statistics；文件模块pathlib、stat、shutil等

# common.py     公共模块
def say_hello(name):
    print('Hello {}'.format(name))

2.导入模块

import math #导入模块
from math import pi #导入模块的指定部分属性或函数
from math import * #导入模块里面的所有内容
from math import pow as mathpow #as类似重命名，把导入的函数或属性重命名为别的名字

3.安装第三方模块（安装第三方模块的工具：pip）

安装Django模块：pip install django
卸载Django模块：pip uninstall django

python文件读写

1.input()函数：接收外部的输入

while True:
    s = input('>>> ')
    if s == 'break':
        break
    result = eval(s)
    print(result)

2.open()函数：打开文件，得到一个文件file对象，而file对象提供方法对文件内容进行读写等操作

open()函数有三个参数：
文件路径：指定需要打开的文件的文件路径
打开模式：针对不同文件（二进制文件、文本文件）以及不同操作（读操作、写操作），会有不同的打开模式
编码：设定打开文件的默认编码
注意：文件使用完毕后，需要使用close()函数正确关闭。

3.打开二进制文件

图片、压缩文件、视频文件、音乐文件等等，这种文件统称为二进制文件，在Python中打开二进制文件，需要不同的打开模式。
b ：二进制模式，打开二进制文件
wb：以二进制格式只写模式打开一个文件，会清除原有的内容
ab：以二进制格式打开一个文件并追加内容，会往文件尾部添加内容
rb：以二进制格式只读模式打开一个文件

4.读取文件内容

读取若干字符--------read()方法，可以读取文件中的若干个字符，它提供一个参数size，可以指定读取字符的数量。
读取一行-----------readline()方法遇到一行结束的时候，就会返回。
读取多行------------readlines()方法，可以读取多行字符，返回一个列表。它提供一个hint参数，表示指定读取的行数，没有指定则默认以列表的形式返回文件所有的字符串。

5.字符串写入文件

w：打开一个文件进行写入，如果文件内容已存在，会清除原有的内容
wb：以二进制格式只写模式打开一个文件，会清除原有的内容
w+：打开一个文件进行读写，如果文件内容已存在，会清除原有的内容
写入若干字符：提供write方法向文件内写入若干字符，它接受一个字符串参数，表示需要写入的字符串。
写入若干行：提供writelines()方法向文件内容写入多行数据，它接受一个列表，表示需要写入的字符串列表。

6.往文件追加内容

a：打开一个文件并追加内容，会往文件尾部添加内容
ab：以二进制格式打开一个文件并追加内容，会往文件尾部添加内容
a+：打开一个文件并使用追加进行读写
seek()方法，可以移动文件的游标位置，它接受一个参数，表示文件的位置，0：文件首部，1：当前位置，2：文件尾部，通过seek()可以把文件游标移动到文件首部但不删除文件的内容

f = open('test.txt', 'a+')
f.seek(0)
content = f.readlines()
f.seek(2)
for line in content:
    f.write(line)
f.close()

7.正确关闭文件

f = open('test.txt', 'a+')
exit(-1) # ==> 模拟程序异常退出
f.close() # ==> close语句永远的不到执行

with关键字对资源进行访问的场合，会确保不管在使用过程中是否发生异常，都会执行必要的“清理”的操作，释放资源

with open('test.txt', 'a+') as f:
    f.seek(0)
    content = f.readlines()
    f.seek(2)
    for line in content:
        f.write(line)

python网络编程

1.套接字Socket与套接字编程

服务端建立需要四步：新建socket、绑定IP和端口(bind)、监听连接(listen)、接受连接(accept)。
客户端需两步：新建socket、连接服务端(connect)。
套接字通过send()函数发送数据，通过recv()函数接收数据。

服务端：

import socket
server = socket.socket() # 1. 新建socket
server.bind(('127.0.0.1', 8999)) # 2. 绑定IP和端口（其中127.0.0.1为本机回环IP）
server.listen(5) # 3. 监听连接
s, addr = server.accept() # 4. 接受连接
print('connect addr：{}'.format(addr))
while True:
    content =s.recv(1024)
    if len(content) == 0:
        break
    s.send(content)
    print(str(content, encoding='utf-8')) # 接受来自客户端的消息，并打印出来
s.close()

客户端：

import socket
client = socket.socket() # 1. 新建socket
client.connect(('127.0.0.1', 8999)) # 2. 连接服务端（注意，IP和端口要和服务端一致）
while True:
    content = input('>>> ')
    client.send(bytes(content, 'utf-8')) # 发送内容，注意发送的是字节字符串。
    content = client.recv(1024)
    print(str(content, encoding='utf-8'))
client.close()

2.发送HTTP请求

from urllib import request
response = request.urlopen('https://www.imooc.com') # 向慕课网官网发出请求
print(response) # ==> <http.client.HTTPResponse object at 0x000001377D631948>
print(response.status) # ==> 200

3.requests库

pip install requests （requests第三方库，安装）

response = requests.get('https://www.imooc.com')
# 打印状态码
print(response.status_code)
# 打印回应头
print(response.headers)

4.响应的内容

response = requests.get('https://www.imooc.com')
content = str(response.content, encoding='utf-8') # ==> 打印具体内容
content_list = content.split('\n') # 分行
for line in content_list:
    if 'href' in line and 'www' in line:
        print(line.strip())

python函数式编程

1.map(f, list)

它接收一个函数 f 和一个 list，并通过把函数 f依次作用在list的每个元素上，map()函数会返回一个迭代器，可以依次迭代得到原来list的元素被函数f处理后的结果。

def f(x):
    return x*x
for item in map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9]):
    print(item)   #[1, 4, 9, 10, 25, 36, 49, 64, 81]

2.reduce()函数

reduce()传入的函数 f 必须接收两个参数，reduce()对list的每个元素反复调用函数f，并返回最终结果值

from functools import reduce
def f(x, y):
    return x + y
print(reduce(f, [1,3,5,7,9])) # ==> 25

3.filter()函数

filter()函数接收一个函数 f 和一个list，这个函数 f 的作用是对每个元素进行判断，返回 True或 False，filter()根据判断结果自动过滤掉不符合条件的元素，并返回一个迭代器，可以迭代出所有符合条件的元素。

def is_not_empty(s):
    return s and len(s.strip()) > 0  
    #s.strip()会默认删除空白字符（包括'\n', '\r', '\t', ' ')
for item in filter(is_not_empty, ['test', None, '', 'str', '  ', 'END']):
    print(item)    # test, str, END

4.自定义排序函数

sorted()函数，默认是由小到大排序列表的元素。

def k(item):
    return item.lower()
print(sorted(['bob', 'about', 'Zoo', 'Credit'], key=k,reverse=True))    # ['Zoo', 'Credit', 'bob', 'about']

5.返回函数

from functools import reduce
def calc_prod(list_):
    def lazy_prod():
        def f(x, y):
            return x * y
        return reduce(f, list_, 1)
    return lazy_prod

f = calc_prod([1, 2, 3, 4])
print(f())

6.闭包

内层函数引用了外层函数的变量（参数也算变量），然后返回内层函数的情况，称为闭包（Closure）。
闭包的特点是返回的函数还引用了外层函数的局部变量，所以，要正确使用闭包，就要确保引用的局部变量在函数返回后不能变。

def count():
    fs = []
    for i in range(1, 4):
        def f(j):
            def g():
                return j*j
            return g
        r = f(i)
        fs.append(r)
    return fs
f1, f2, f3 = count()
print(f1(), f2(), f3())

7.匿名函数

lambda定义：lambda x: x * x，就可以完成原来显式定义的f(x)函数的功能，冒号前面的x表示匿名函数的参数，后面的是一个表达式，匿名函数有个限制，就是只能有一个表达式，不写return，返回值就是该表达式的结果。

result = [item for item in map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9])]
print(result) # ==> [1, 4, 9, 16, 25, 36, 49, 64, 81]
from functools import reduce
print(reduce(lambda x, y: x + y, [1,3,5,7,9]))

8.无参数的decorator

import time
def performance(f):
    def fn(*args, **kw):
        t1 = time.time()
        r = f(*args, **kw)
        t2 = time.time()
        print('call %s() in %fs' % (f.__name__, (t2 - t1)))
        return r
    return fn
@performance
def factorial(n):
    return reduce(lambda x,y: x*y, range(1, n+1))
print(factorial(10))

9.有参数的decorator

import time
def performance(unit):
    def perf_decorator(f):
        def wrapper(*args, **kwargs):
            t1 = time.time()
            r = f(*args, **kwargs)
            t2 = time.time()
            t = (t2 - t1) * 1000 if unit == 'ms' else (t2 - t1)
            print('call {}() in {} {}'.format(f.__name__, t, unit))
            return r
        return wrapper
    return perf_decorator
@performance('ms')
def factorial(n):
    return reduce(lambda x,y: x*y, range(1, n+1))
factorial(10)

10.偏函数

偏函数指的就是“创建一个调用另外一个部分参数或变量已经预置的函数”的函数的用法

import functools
sorted_ignore_case = functools.partial(sorted, key=lambda item: item.lower())
a = sorted_ignore_case(['bob', 'about', 'Zoo', 'Credit'])
print(a)