Python之面向对象总结,Pip环境配置

官方安装 

一、面向对象

      a、迭代器协议 : 内部实现了__iter__
__next__方法

Step 2:   安装pycharm

  1. 自定义一个步骤,至于cdkey,csdn很多
  2. pycharm关联conda中的python解释器的方法,参考链接: 

 

     13、类命名空间与对象、实例的命名空间

6、参数

Step 1: anaconda安装及注意事项

  1. 默认步骤安装
  2. 安装中勾选添加环境变量 
      图片 1
  3. 安装完成后,可以在Windows的cmd中执行python命令,看是否可以进入python运行界面

  4. 查看系统环境变量中的用户path变量(我的信息如右):C:\Anaconda3;C:\Anaconda3\Library\mingw-w64\bin;C:\Anaconda3\Library\usr\bin;C:\Anaconda3\Library\bin;C:\Anaconda3\Scripts

  5. 查看安装完成的包:
    Windows命令行执行:conda list

                
需要注意的是,如果返回的是对象的方法,返回出来的是对象的内存地址,如果需要运行这个方法,可以在后面添加一对()

     a、在一个函数里调用自己

Step 3:  安装python3

  1. 进入python.org下载最新python,链接:
  2. 安装python3.6时注意勾选添加环境变量选项,图片 2

     

  3. pip安装 图片 3

     

     

     

                              c、提高复用性

add2 = lambda x,y : x+y
ret = add2(1,2)
print(ret)

conda安装

             
 hasattr:hasattr(object,name)判断一个对象是否有name属性或者name方法。有就返回True,没有就返回False

默认参数

前置操作

软件名:anaconda 
版本:Anaconda3-5.0.1-Windows-x86_64清华镜像 
下载链接:

软件名:Pycharm 
版本:pycharm-professional-2017.3.2  下载地址:百度即可

软件名:python   
版本:3.6      下载地址:python.org

 


 

   4、对象/实例:具体的某一个事物(隔壁阿花、楼下旺财)

算年龄

面相对象的组合用法:

       2、返回多个值

     
 b、缺点:一套流水线或者流程就是来解决一个问题,代码就是牵一发而东莞全身

    b、返回要返回的值

         
 a、常见一个类就会创建一个类的名称空间,用来储存类中定义的所有名字,这些名字成为类的属性

     a、实参:调用函数的时候传入的参数

           a、继承

装饰器的固定方式

  •  静态属性就是直接在类中定义的变量
  • 动态属性就是定义在类中的方法

带参数的装饰器

                  2、封装原则:

     a、位置参数必须传值

                              b、封装使用

i = pow(2,100)  

print(i) 

 

12、作用域

  

   h、max()最大数 min()  最小数

     e、内置方法:item系列

图片 4图片 5

class Person:   #定义一个人类
    role = 'person'  #人的角色属性都是人
    def __init__(self,name):
        self.name = name  # 每一个角色都有自己的昵称;

    def walk(self):  #人都可以走路,也就是有一个走路方法
        print("person is walking...")


print(Person.role)  #查看人的role属性
print(Person.walk)  #引用人的走路方法,注意,这里不是在调用

10、动态参数

     
 a、优点:解决程序的扩展性,对某一个对象单独修改,会立刻反应到整个体系中

1、为什么要用函数

                              a、将不需要对外提供的内容都隐藏起来

   k、zip —意思就是取两个变量中索引相对应的值

python自带多态:

  多态:同一类事物的多种状态

  python里处处都是多态,只是我们一般发现不了

  操作的时候不需要关心这个对象的数据类型,你只要用就行了

  l、、open—打开,关闭,close

               isinstance(obj,cls)检查是否obj是否是类 cls
的对象

     e、递归结束标志:return

 

   g、pow(x,y) —-就是求x的y次方

                   多态指的是:一类实物有多种状态

    d、divmod  除商得余数—例如分页

           b、封装

l =[i*i for i in range(100)]
print(l)

                 
a:声明某个子类兼容于某基类,定义一个接口类Interface,接口类中定义

只写return

圆的周长与面积

   

class Foo:
    pass
class Son(Foo):
    pass
s=Son()

print(isinstance(s,Son))

图片 6图片 7

     
 c、python面向对象中的反射:通过字符串的形式操作对象相关的属性,python中一切事物都是对象(都可以用反射)

def f1():  

    return 123  

f2 = lambda :123  

r1 = f1()  

r2 = f2()  

print(r1,r2)

def f3(a1,a2):  

    return a1 + a2  

f4 = lambda a1,a2: a1 + a2  

r3 = f3(1,2)  

r4 = f4(3,4)  

print(r3,r4) 

                  1、优点:

ret = eval("1 + 3")  

print(ret)  

结果:4 
class Person:   #定义一个人类
    role = 'person'  #人的角色属性都是人
    def walk(self):  #人都可以走路,也就是有一个走路方法,也叫动态属性
        print("person is walking...")

class 类名:
    类属性 = None
    def __init__(self,对象属性):
        self.对象属性 = 对象属性

    def 方法名(self):
        pass

实例 = 类名(10)
实例.方法名()

      c、可迭代对应标志:__iter__

   6、
在python中,用变量表示特征,用函数表示技能,因而具有相同特征和技能的一类事物就是‘类’,

    a、参数—-站在定义函数的角度

class Foo:
    def __del__(self):
        print('fgs')
f=Foo()
print(123)
print(123)
del f
print(123)
print(123)
print(123)

     
a、希望这个数据类型里的东西也可以使用for被一个一个的取出来,那我们就必须满足for的要求

   
10、例化:类名加括号就是实例化,会自动触发__init__函数的运行,可以用它来为每个实例定制自己的特征

图片 8图片 9

                 
b:继承基类的方法,并且做出自己的改变或者扩展(代码重用)***
  ***

              a、*args

                              d、提高安全性

位置参数

class Person:   #定义一个人类
    role = 'person'  #人的角色属性都是人
    def walk(self):  #人都可以走路,也就是有一个走路方法
        print("person is walking...")


print(Person.role)  #查看人的role属性
print(Person.walk)  #引用人的走路方法,注意,这里不是在调用
 
class Foo(object):
    pass

class Bar(Foo):
    pass

issubclass(Bar, Foo)

25、内置函数

                              a、将变化隔离

      b、
 全局作用域:包含内置名称空间、全局名称空间,在整个文件的任意位置都能被引用、全局有效

property是一种特殊的属性,访问它时会执行一段功能(函数)然后返回值

for i in range(100):
    print(i*i)

                       
 **
 了一些接口名(就是函数名)且并未实现接口的功能,子类继承接口类,并且实现接口中的功能**

         1、位置参数

                  3、私有变量和私有方法

         1、按照位置传参

          a、内置方法:isinstance和issubclass

     d、递归实例

检查是否含有某属性---hasattr 返回布尔值
获取属性---getattr   没有就会报错
设置属性---setattr
删除属性---delattr

生成器函数

       

View Code

   5、实例化:类——>对象的过程

li = [11,22,123,1]  

r = max(li)  

print(r)  

a = min(li)  

print(a) 

    11、

 

   7、对象是则是这一类事物中具体的一个

         1、返回一个值

           b、而类有两种属性:静态属性和动态属性

li1 = [11,22,33,44]  

li2 =["a",'VV',"c","E"]  

r = zip(li1,li2)  

print(r)  

for i in r :  

    print(i)
self:在实例化时自动将对象/实例本身传给__init__的第一个参数,你也可以给他起个别的名字.

对象/实例只有一种作用:属性引用

class 类名:
    def __init__(self,参数1,参数2):
        self.对象的属性1 = 参数1
        self.对象的属性2 = 参数2

    def 方法名(self):pass

    def 方法名2(self):pass

对象名 = 类名(1,2)  #对象就是实例,代表一个具体的东西
                  #类名() : 类名+括号就是实例化一个类,相当于调用了__init__方法
                  #括号里传参数,参数不需要传self,其他与init中的形参一一对应
                  #结果返回一个对象
对象名.对象的属性1   #查看对象的属性,直接用 对象名.属性名 即可
对象名.方法名()     #调用类中的方法,直接用 对象名.方法名() 即可

dir(类) #返回类中的所有名字列表
isinstance(对象,类) #判断对象是否为类的实例
print(Person.__dict__) # 返回一个字典 key是属性名,value是属性值
print(Person.__module__)  #person类所在的模块
print(Person.__name__,type(Person.__name__)) #字符串数据类型的类名

     
a、生成器函数:常规函数定义,但是,使用yield语句而不是return语句返回结果。yield语句一次返回一个结果,在每个结果中间,

        1、
反射:可以用字符串的方式去访问对象的属性,调用对象的方法(但是不能去访问方法),python中一切皆对象,都可以使用反射。

def hei():
    x = 20
    def inner():
        print(x)  #局部的
    return inner

i = hei()
i()  #全局

               delattr:删除该对象指定的一个属性

def mylen():
    """计算s1的长度"""
    s1 = "hello world"
    length = 0
    for i in s1:
        length = length+1
    return length

str_len = mylen()
print(str_len)

     14、面向对象的三大特征

13、闭包

     
 a、优点:极大的降低了写程序的复杂度,只需要顺着执行的步骤,堆叠代码即可

a = 10 / 3  

print(a)  

r = divmod(10,3)  

print(r)  

结果:  

3.33333335  

(3,1) 

        2、反射有四种方法:

    b、返回值不为None

 class 类名(父类名):
      想在子类中实现调用父类的方法
      在类内 ——super(子类名,self).方法名()
      在类外面 ——super(子类名,对象名).方法名()
      如果不指定继承的父类,默认继承object
      子类可以使用父类的所有属性和方法
      如果子类有自己的方法就执行自己的的
      如果是子类没有的方法就执行父类的
      如果子类父类都没有这个方法就报错

继承、抽象、派生
继承 是从大范围到小范围
抽象 小范围到大范围
派生 就是在父类的基础上又产生子类——派生类
        父类里没有的 但子类有的 ——派生方法
        派生属性
方法的重写
    父类里有的方法,在子类里重新实现

 

 

   1、面向过程

            2、局部命名空间

        b、内置方法:issubclass(sub, super)检查sub类是否是
super 类的派生类 

不写return

                             
a、在python中用双划线的开头的的方式降属性隐藏起来(设置私有的)

   e、eval  —–强制不转换输入类型的格式

列子:

n*n

python2
class Dad:  #经典类
class Dag(object)  #新式类

python3
class Dad  ==  class Dag(object) #新式类

22、列表推导式

       d、内置方法:__del__

      a、计算func的执行时间

析构方法,当对象在内存中被释放时,自动触发执行。

   a、返回值为None    不接受

创建一个对象/实例就会创建一个对象/实例的名称空间,存放对象/实例的名字,称为对象/实例的属性

16、装饰器应用场景

    9、属性引用(类名.属性)

n*n

    15、反射     

图片 10图片 11

              2、继承的两种用途:                

                           ‘__next__’ in dir(o)

         
 c、多态:”多态指的是一类事物有多种形态(比如:老师.下课铃响了(),学生.下课铃响了(),老师执行的是下班操作,学生执行的是放学操作,虽然二者消息一样,但是执行的效果不同)

 

注:此方法一般无须定义,因为Python是一门高级语言,程序员在使用时无需关心内存的分配和释放,因为此工作都是交给Python解释器来执行,所以,析构函数的调用是由解释器在进行垃圾回收时自动触发执行的。

     a、 匿名函数 简单的需要用函数去解决的问题 匿名函数的函数体
只有一行,也叫lambda

   3、 类:具有相同特征的一类事物(人、狗、老虎)

   函数定义—返回值

类名
    类名.类属性
   类名.方法名

实例 = 类名(参数,参数)  #实例就是对象

实例
    实例.方法名()
   实例.对象属性

实例增加属性
实例.新的属性名 = 1000
print(实例.新的属性名)

图片 12图片 13

网站地图xml地图