导入模块：

1、from 模块名/包名 import *（所有内容）/函数名（指定函数)，如果是导入所有内容，导入后可以直接调用该模块内的所有函数

eg.

#common.py
def say_hello(name):
    print('hello,'+name)

from common import *
say_hello('bob')

#输出：hello，bob

2、只用【import 模块名】导入模块，则调用所导入的模块内的函数时，需要用【模块名.函数名】调用

import common
common.say_hello('bob')

#输出：hello，bob

3、如果从一个模块中导入的函数与文件中的函数名重名：

        1>直接导入模块，不指定函数名

        2>from模块名 import 函数名 as 新函数名   把导入的函数或者属性重命名为

（from 包 ）import 模块名   （从某个包里）导入某个模块 

包一般含有__init__.py文件的文件夹

print(模块名.函数名）  调用模块里的函数

class Rational(object):
    def __init__(self,p,q): #分数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)  #分子：self.p*r.q+self.q*r(通分，让两个数的分母相等），分母：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):
        return '{}/{}'.format(self.p,self.q)

r1 = Rational(1,2)
r2 = Rational(2,3)
print(r1 + r2)
print(r1 - r2)
print(r1 * r2)
print(r1 / r2)

1. python的__init__方法相当于java的构造方法，__变量相当于java的private修饰的变量；

2. python的实例方法首个参数是self，表示当前调用此方法的实例。可通过此方法访问私有变量；

3. python的类变量相当于java的静态变量；

import math

def add(x, y, f):
   return f(x) + f(y)

print(add(25, 9, math.sqrt))

高阶函数：把函数作为变量

type（）获得变量的类型

dir（） 获得变量的所有属性，如果是某个类的实例变量，那么获得的属性会包括这个类里def的方法

getattr（变量名，变量的属性名，默认返回值）获得这个变量的属性的实际参数，如果属性不存在，且没有设置默认返回值，会报错

setattr（变量名，变量的属性名，新的属性参数）设置新的参数

【**kw】,代表传入可变关键字参数，一个*代表的是传入一个元组(tuple),而两个*代表的是传入一个字典(dict)

判断类型

isinstance（需要判断的数据a，判断是否是类型b）输出True或者False

b可以是类，可以是int，str等Python自有数据类型

子类继承父类，并可能添加了其他属性信息，所以instance（子类，父类）是True，instance（父类，子类）是false。

eg：老师是子类，人是父类。

instance（子类，父类）→老师是人【正确】

instance（父类，子类）→人是老师【错误】

判断类型

isinstance（需要判断的数据a，判断是否是类型b）输出True或者False

b可以是类，可以是int，str等Python自有数据类型

子类继承父类，并可能添加了其他属性信息，所以instance（子类，父类）是True，instance（父类，子类）是false。

eg：老师是子类，人是父类。

instance（子类，父类）→老师是人【正确】

instance（父类，子类）→人是老师【错误】

1、class Student()定义的时候，需要在括号内写明继承的类Person

2、在__init__()方法，需要调用super(子类名, self).__init__(父类属性1, 父类属性2，...)，来初始化从父类继承过来的属性

super()中是逗号，后边是【  .__init__】

class a():
    def __init__(self , j , k): #初始化a类的jk属性
        self.j = 
        self,k = 
  
 class b(a):  #a是父类，b是a的子类，b要继承a，需要在定义的时候在（）中填写要继承的类名
     def __init__(self, j , k , l): #初始化b类的属性，需要包括a类的属性
         super(b,self).__init__(j , k )#在__init__()方法，需要调用super(Student, self).__init__(name, gender)，来初始化从父类继承过来的属性
         self.l =

class Animal(object):
    __localtion = 'Asia' 
    __count = 0  #类的私有属性
    def __init__(self, name, age):
        self.name = name
        self.age = age
        Animal.__count += 1  #__count是类的，所以要带上类名

    @classmethod    #私有属性调用需要使用classmethod定义类方法
    def get_count(cls):
        return cls.__count
        
     @classmethod
    def set_localtion(cls, localtion):  #调用类方法，给localtion赋值，（）第一个是cls，第二个是参数
        cls.__localtion = localtion

    @classmethod
    def get_localtion(cls):  #获取赋值后的localtion
        return cls.__localtion

dog = Animal('wangwang', 1)
cat = Animal('mimi', 3)
pig = Animal('panpan', 1)
count = Animal.get_count()
print(count) #结果是3

Animal.set_localtion('gz')  #给Animal的__localtion赋值，赋值时直接调用，不需要再加其他名字和等号，实例化才需要名字和等号
print(Animal.get_localtion())  打印

class 类名（）:

def __init__（self, 属性1，属性2，...）#init是初始化

self.属性

self.属性

def 方法名():

方法函数

实例化：

实例名 = 类名.(属性1，属性2，...)

调用：

实例名.方法名()

如果类和实例存在同名属性，则该属性实例的优先级高于类。

不能通过实例修改类的固定属性

class Animal(object):
   def __init__(self, name, age, localtion):
       self.__name = name  #带双__是私有属性，可以通过内部定义def方法访问
       self.__age = age
       self.__localtion = localtion

   def set_name(self, name):#设置私有属性，通过这个设置，可以单独调用set_name方法对实例的name属性进行修改，不需要调用完整的实例
       self.__name = name

   def get_name(self):  #访问私有属性
       return self.__name

   def set_age(self, age):
       self.__age = age

   def get_age(self):
       return self.__age

   def set_localtion(self, localtion):
       self.__localtion =localtion

   def get_localtion(self):
       return self.__localtion

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

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

reduce()函数接收的参数和 map() 类似，一个函数 f，一个list，但行为和 map()不同，reduce()传入的函数 f 必须接收两个参数，reduce()对list的每个元素反复调用函数f，并返回最终结果值。