python学习笔记

python特点
1. 面向对象，所以和C++一样有类，对象，继承等概念
2. 解释型
3. CPython

python内置函数

因为所有类都继承于object，所以父类实现中肯定有对应的内置函数，所以使用全局函数调用时相当于重载运算符一样去找内部函数

内置函数
abs()	delattr()	hash()	memoryview()	set()
all()	dict()	help()	min()	setattr()
any()	dir()	hex()	next()	slicea()
ascii()	divmod()	id()	object()	sorted()
bin()	enumerate()	input()	oct()	staticmethod()
bool()	eval()	int()	open()	str()
breakpoint()	exec()	isinstance()	ord()	sum()
bytearray()	filter()	issubclass()	pow()	super()
bytes()	float()	iter()	print()	tuple()
callable()	format()	len()	property()	type()
chr()	frozenset()	list()	range()	vars()
classmethod()	getattr()	locals()	repr()	zip()
compile()	globals()	map()	reversed()	__import__()
complex()	hasattr()	max()	round()

变量类型和运算符
1. 通用
列表、元组、字典、集合
1. list
  1. [x,y,...]表示，相当于STL中的vector，但是数据类型可变，可以灵活使用，操作更加灵活
2. tuple
  1. (x,y)表示，相当于const版本的list，元组建好不可被修改，要么就新起一个变量
3. dict
  1. {key:value}表示，相当于STL中的unordered_map，所以没有排序，且键值不重复，可以看成是哈希表实现
  2. keys()
  3. values()
  4. items()
4. set
  1. {unit,unit2}表示，相当于STL中的unordered_set，没有排序，且键值唯一
5. frozenset
  1. 相当于const版本的set
  2. 可以看出python中对于const类型也会特别指明，除了dict
字符串
1. 有很多函数，需要用到查询手册
流程控制
1. 通用

函数和lambda表达式

位置参数和关键字参数

python里面建议不管是调用还是定义函数，都指明关键字和默认参数，可以避免许多错误

def dis_str(str1="a",str2="b"):
    print("str1:",str1)
    print("str2:",str2)
#位置参数
dis_str("z","x")
#关键字参数
dis_str(str2="z",str1="x")
dis_str()

传入任意个参数
1. （*args,**kwargs）
  1. 一个是元组，一个是字典传入
2. 序列中的元素传递参数
  1. 逆向收集参数
  2. 如果是list tuple会按次序赋值
  3. 字典指定关键字的相当于按照键值赋给对应的关键字

偏函数

包装原有的函数，自定义默认参数

from functools import partial
#定义个原函数
def display(name,age):
    print("name:",name,"age:",age)
#定义偏函数，其封装了 display() 函数，并为 name 参数设置了默认参数
GaryFun = partial(display,name = 'Gary')
#由于 name 参数已经有默认值，因此调用偏函数时，可以不指定
GaryFun(age = 13)

全局变量和局部变量

获得指定作用域范围中的变量

#globals() 返回一个字典

#全局变量
Pyname = "Python教程"
Pyadd = "1"
def text():
    global Pyname  #这个声明会在局部使用全局的变量
    print(globals()["Pyname"])
    #局部变量
    Shename = "shell教程"
    Sheadd= "2"
print(globals())


#local() 类似global 返回当前作用域的所有变量

#全局变量
Pyname = "Python教程"
Pyadd = "1"
def text():
    #局部变量
    Shename = "shell教程"
    Sheadd= "2/"
    print("函数内部的 locals:")
    print(locals())
text()
print("函数外部的 locals:")
print(locals())

#vars(object)   直接指定获取哪一个区域内的所有变量，如果没有参数，就是当前作用域
 #全局变量
Pyname = "Python教程"
Pyadd = "1"
class Demo:
    name = "Python 教程"
    add = "2"
print("有 object：")
print(vars(Demo))
print("无 object：")
print(vars())

python 函数
1. python的函数非常灵活，可以看成是一种函数引用当做变量使用

闭包函数

相当于返回一个函数

#闭包函数，其中 exponent 称为自由变量
def nth_power(exponent):
    def exponent_of(base):
        return base ** exponent
    return exponent_of # 返回值是 exponent_of 函数
square = nth_power(2) # 计算一个数的平方
cube = nth_power(3) # 计算一个数的立方

print(square(2))  # 计算 2 的平方
print(cube(2)) # 计算 2 的立方

匿名函数
1. 可以看成是临时函数
2. lambda函数，语法比C++简单，显式声明lambda
```
add = lambda x,y:x+y
print(add(3,4))
```

函数式编程

listDemo = [1, 2, 3, 4, 5]
new_list = map(lambda x: x * 2, listDemo)
print(list(new_list))

listDemo = [1, 2, 3, 4, 5]
new_list = map(lambda x,y: x-y>0,[3,5,6],[1,5,8] )
print(list(new_list))

import functools
listDemo = [1, 2, 3, 4, 5]
product = functools.reduce(lambda x, y: x * y, listDemo)
print(product)

python3对函数的一些注释

def square(number:"一个数字")->"返回number的平方":
  return number**2
print(square(10))
print(square.__annotations__)
#{'number': '一个数字', 'return': '返回number的平方'}

类和对象

class 定义对象
1. 类似C++也是class
构造函数
1. 类似C++有默认构造函数，也有自定义
2. 同样的这个函数遵守关键字和默认参数的那套规则，建议是在定义的时候使用关键字和默认参数
self
1. 类似this指针
对象创建和使用
1. 类型C++中初始化，构建一个临时对象然后剪贴或复制给目标的写法

类变量和实例变量

可以看出对象所有的变量是动态添加的，如果没有调用实例属性所在函数，对象就不会有。

class CLanguage :
    class_1="sss"    #直接在类内定义的叫做类所有的变量，可以通过类名访问
    def __init__(self):
        self.name = "1"
        self.add = "2"
    # 下面定义了一个say实例方法
    def say(self):
        self.catalog = 13

clang = CLanguage()
print(clang.name)
print(clang.add)
#由于 clang 对象未调用 say() 方法，因此其没有 catalog 变量，下面这行代码会报错
#print(clang.catalog)

clang2 = CLanguage()
print(clang2.name)
print(clang2.add)
#只有调用 say()，才会拥有 catalog 实例变量
clang2.say()
print(clang2.catalog)

类方法、实例方法、静态方法

class CLanguage:
    #类构造方法，也属于实例方法
    def __init__(self):        #绑定到对象
        self.name = "1"
        self.add = "2"

    #下面定义了一个类方法       和属性不一样，属性在类内直接定义是类属性，但是方法需要额外加上修饰
    @classmethod
    def info(cls):            #绑定到类
        print("正在调用类方法",cls)

    #静态方法 静态方法的调用，既可以使用类名，也可以使用类对象
    @staticmethod
    def info(name,add):       #没有任何self cls 所以无法调用类属性和类方法
        print(name,add)

property()

class CLanguage:
    #构造函数
    def __init__(self,n):
        self.__name = n
    #设置 name 属性值的函数
    def setname(self,n):
        self.__name = n
    #访问nema属性值的函数
    def getname(self):
        return self.__name
    #删除name属性值的函数
    def delname(self):
        self.__name="xxx"
    #为name 属性配置 property() 函数
    name = property(getname, setname, delname, '指明出处')
    #可以直接通过这种形式去定义一个属性
#调取说明文档的 2 种方式
#print(CLanguage.name.__doc__)
help(CLanguage.name)
clang = CLanguage("1233")
#调用 getname() 方法
print(clang.name)
#调用 setname() 方法
clang.name="Python教程"
print(clang.name)
#调用 delname() 方法
del clang.name
print(clang.name)

封装
1. python中__表示私有

继承

class Bird:
    #鸟有翅膀
    def isWing(self):
        print("鸟有翅膀")
    #鸟会飞
    def fly(self):
        print("鸟会飞")
class Ostrich(Bird):
    # 重写Bird类的fly()方法
    def fly(self):
        print("鸵鸟不会飞")

# 创建Ostrich对象
ostrich = Ostrich()
#调用 Ostrich 类中重写的 fly() 类方法
ostrich.fly()

python支持多继承，但不建议使用

枚举类

from enum import Enum
class Color(Enum):
    # 为序列值指定value值
    red = 1
    green = 2
    blue = 3

类特殊成员

内置函数
1. 相当于内置函数和类内的方法一一对应
2. __call__() 重载()运算符

运算符重载

重载运算符	含义
__new__	创建类，在 __init__ 之前创建对象
__init__	类的构造函数，其功能是创建类对象时做初始化工作。
__del__	析构函数，其功能是销毁对象时进行回收资源的操作
__add__	加法运算符 +，当类对象 X 做例如 X+Y 或者 X+=Y 等操作，内部会调用此方法。但如果类中对 __iadd__ 方法进行了重载，则类对象 X 在做 X+=Y 类似操作时，会优先选择调用 __iadd__ 方法。
__radd__	当类对象 X 做类似 Y+X 的运算时，会调用此方法。
__iadd__	重载 += 运算符，也就是说，当类对象 X 做类似 X+=Y 的操作时，会调用此方法。
__or__	“或”运算符 \|，如果没有重载 __ior__，则在类似 X\|Y、X\|=Y 这样的语句中，“或”符号生效
__repr__，__str__	格式转换方法，分别对应函数 repr(X)、str(X)
__call__	函数调用，类似于 X(args, *kwargs) 语句
__getattr__	点号运算，用来获取类属性
__setattr__	属性赋值语句，类似于 X.any=value
__delattr__	删除属性，类似于 del X.any
__getattribute__	获取属性，类似于 X.any
__getitem__	索引运算，类似于 X[key]，X[i:j]
__setitem__	索引赋值语句，类似于 X[key], X[i:j]=sequence
__delitem__	索引和分片删除
__get__, __set__, __delete__	描述符属性，类似于 X.attr，X.attr=value，del X.attr
__len__	计算长度，类似于 len(X)
__lt__，__gt__，__le__，__ge__，__eq__，__ne__	比较，分别对应于 <、>、<=、>=、=、!= 运算符。
__iter__，__next__	迭代环境下，生成迭代器与取下一条，类似于 I=iter(X) 和 next()
__contains__	成员关系测试，类似于 item in X
__index__	整数值，类似于 hex(X)，bin(X)，oct(X)
__enter__，__exit__	在对类对象执行类似 with obj as var 的操作之前，会先调用 __enter__ 方法，其结果会传给 var；在最终结束该操作之前，会调用 __exit__ 方法（常用于做一些清理、扫尾的工作）

迭代器和自定义序列

方法名	功能
__len__(self)	返回序列类中存储元素的个数。
__contains__(self, value)	判断当前序列中是否包含 value 这个指定元素。
__getitem__(self, key)	通过指定的 key（键），返回对应的 value（值）。
__setitem__(self, key)	修改指定 key（键）对应的 value（值）。
__delitem__(self, key)	删除指定键值对。

生成器yield

def intNum():
    print("开始执行")
    for i in range(5):
        yield i
        print("继续执行")
num = intNum()

#调用 next() 内置函数
print(next(num))
#调用 __next__() 方法
print(num.__next__())
#通过for循环遍历生成器
for i in num:
    print(i)


def foo():
    bar_a = yield "hello"
    bar_b = yield bar_a
    yield bar_b

f = foo()
print(f.send(None))   #开始执行，碰到第一个yield返回
print(f.send("1"))    #继续执行，传入参数，碰到第二个yield返回
print(f.send("2"))

函数装饰器

可以看成是函数的一种叠加，在子函数执行前先执行母函数

def funA(fn):
    # 定义一个嵌套函数
    def say(*args,**kwargs):
        fn(*args,**kwargs)
    return say

@funA
def funB(arc):
    print("111：",arc)

@funA
def other_funB(name,arc):
    print(name,arc)

funB("222")
other_funB("333：","444")

异常处理

习惯使用logging而不是print去获取输出信息

import logging
logging.basicConfig(level=logging.DEBUG, format=' %(asctime)s - %(levelname)s - %(message)s')
logging.debug('Start of program')
def factorial(n):
    logging.debug('Start of factorial(%s%%)' % (n))
    total = 1
    for i in range(n + 1):
        total *= i
        logging.debug('i is ' + str(i) + ', total is ' + str(total))
    logging.debug('End of factorial(%s%%)' % (n))
    return total
print(factorial(5))
logging.debug('End of program')

模块和包
1. 导入package和.py
2. __init__.py
  1. 在导入目录时自动调用

python学习笔记

C/C++/C#相关栏目本月热门文章