python学习笔记

python基础语法学习

该文档是刚开始学习python时的笔记，参考的是廖雪峰python教程，大家有时间也可以看下~

先上一幅图，此为某位大神在python社区发布的，现在找不到链接了，如果大家有发现，可以告诉我哈~~

基本语法

#多行文本的写法
'''
第一行
第二行
第三行
'''
#默认使用utf8编码，中文会修改为三个字节，每个字母为一个字节，用法类同于b开头的字符串
'abc'.encode()
#数组操作
arrya=['A','B','c']
#插入元素
array.insert(index,'D')
#显示并删除最后一个元素
array.pop()
#显示并删除指定位置元素
array.pop(index)
#指定索引位置元素值修改
array[index]='E'
#数组的排序
array.sort()
## 切片,取前10条记录，也可以从倒序，最后一个元素为-1
array[0:10]
#元组 tuple ，指向是不可变的，只能显示不能修改，代码更安全，如果元素有数组时，是可以修改数组指向值的
array=(1,2,3)
#if的用法
age =18
if age >=18:
print('')
else:
print('')
#字符串转换为数字
int(str)
array =['a','b','c']
for ele in array:
print(ele)
#生成0－5的整数序列
list(range(5))
##python中有map的概念
map ={'key':value,'key2':value2}
#指定key是否存在于map中,返回boole值
key in map
#python中也有set的概念
s =set([1,2,3])
s.add(4)
s.remove(4)
#set可以做交集和并集
set1 & set2
set1 | set2

类型转换

int('123')
int(12.25)
str(123)
bool('')
bool(1)

内置函数

max(1,2,3)
abs(-1)

函数定义,第二个参数为默认值参数，可以不传入值

def function_name(param1,param2=2):
XXXXXX;
return
# 可变参数，接收的为元数组tuple，不允许改变，如果调用者有一个数组，需要将数组转换为可变参数才可以，如数组为array=[],，则使用 function_name(*array)来调用即可;
def function_name(*param1)
#关键字参数，将在内部组装为一个map,同时也可以个体**map将一个map转换为关键字参数，正常调用为: person("","",city="",job="")
def person(name, age,**kw):
print('name:', name,'age:', age,'other:', kw)
#指定参数名的关键字参数，使用*进行分隔，也可以使用默认值参数
def person(name, age,*, city='Beijing', job):
print(name, age, city, job)

高级特性

#切片
array=[1,2,3]
array[0:3]
#迭代
for ele in array
for key in map
for value in map.values()
for key,value in map.intems()
#判定元素是否可迭代
isinstance([1,2,3],Iterable)
# 列表生成表达式
[x * x for x in range(1,11)if x %2==0]
==>[4,16,36,64,100]
[m+n for m in'ABC'for n in'XYZ']
#所有元素小写，除去不符合要求的除去
L1 =['Hello','World',18,'Apple',None]
print([ele.lower()for ele in L1 if isinstance(ele, str)])
#生成器，比如说想要生成100W个数据，但最后才用到了几个，如查在直接以上面的列表表达式的话可能就不合适，所以想在需要的时候再去动态生成会比较好
#直接将上面数组格式的中括号改为小括号即可
gen =(x * x for x in range(1,11))
for g in gen:
print(g)
#也可以使用next(gen)来遍历，不过到最后一个之后的下一个会报错，所以基本上不使用next()的方法来执行
#同时函数也可以写作是生成器，如:
>>>def fib(max):
... n,a,b =0,0,1
...while n < max:
...print(b)
... a, b = b, a+b
... n+=1
...return'done'
...
>>> fib(3)
1
1
2
#在使用时，如果触发到yield时就会中断返回，到下次时从yield开始向下执行
>>>def fib1(max):
... n, a, b =0,0,1
...while n < max:
...yield b
... a, b = b, a+b
... n+=1
...return'done'
...
>>> f = fib1(6)
>>> f
<generator object fib1 at 0x0000000001E5A468>
#杨辉三角的写法
>>>def triangle(max):
... lineArray =[1]
...while--max >0:
...yield lineArray
... lineArray =[1]+[lineArray[i]+ lineArray[-i]for i in range(len(lineArray))if i >0]+[1]
...
>>> g = triangle(5)
>>> g
<generator object triangle at 0x0000000001E5A410>
>>>next(g)
[1]

迭代器

#判定是否可送代,可以遍历的类型为:字符串、集合、元集合、生成器、set、map等，可以通过for遍历的均为可迭代的
>>from collections importIterable
>> isinstance([],Iterable)
# 可以使用next()来获取下个元素的称之为迭代器，目前来说只有生成器，也就是说迭代器是懒散加载的，在之前并不知道其包含的元素
>>>from collections importIterator
>>> isinstance([],Iterator)
False
>>> isinstance((x for x in range(10)),Iterator)
True

函数式编程

可以返回函数，返回的函数在调用时才会开始计算值，所以返回的函数值中不要包含循环变量值，否则会出现异常。

## 返回函数，在返回的函数中不要包含循环的变量
#因为返回的函数中包含有循环变量，到最后计算的时候全更新为相同的值了
>>>
>>>def count():
... fs =[]
...for i in range(1,3):
...def f():
...return i*i
... fs.append(f)
...return fs
>>> f1, f2 = count()
>>> f1()
4
>>> f2()
4
>>>
##处理方式就是再加一层函数
>>>def count():
...def f(j):
...def g():
...return j*j
...return g
... fs =[]
...for i in range(1,3):
... fs.append(f(i))
...return fs
...
>>> a, b = count()
>>> a()
1
>>> b()
4

高级函数

## map 和 reduce ,map将遍历每个元素，对每个元素进行处理，生成一个新的集合，reduce将集合中各个元素进行汇总，返回一个值
# 转换为符点数，利于map、reduce来处理，先将字符串转换为集合，再处理集合
def str2float(floatstr):
def char_to_float(element):
if str(element).__eq__("."):
return-1
returnint(element)
arr = map(char_to_float, floatstr)
point =0
def to_float(x, n):
nonlocal point
if n ==-1:
point =1
return x
if point ==0:
return x*10+ n
else:
point *=10
return x + n/point
return reduce(to_float, arr,0.0)
print('str2float(\'123.456\') =', str2float('123.456'))
##filter 过滤器，如果函数返回True，则保留，返回False，则排除
#显示所有的回数
def is_palindrome(n):
if n <10:
returnFalse
elementstr = str(n)
for i in range(0, elementstr.__len__()):
if elementstr[i]!= elementstr[-i -1]:
returnFalse
returnTrue
output = filter(is_palindrome, range(1,1000))
print(list(output))
# 排序 可以带两个参数，key(指定排序字段与字段的处理函数)与 reverse(是否倒序等)
L =[('Bob',75),('adam',92),('Bart',66),('Lisa',88)]
def by_name(t):
return str.lower(t[0])
L2 = sorted(L, key=by_name, reverse=False)
print(L2)

匿名函数

# 只对简单方法才可以写匿名函数，如
# 前一部分为参数，后一部分为表达式
>>>
>>> func =lambda x: x * x
>>> func
<function<lambda> at 0x02155618>
>>> func(1)
1

装饰器

# 这个方法待测
def log(func):
def wrapper(*args,**kw):
print('call %s():'% func.__name__)
return func(*args,**kw)
return wrapper
@log
def now():
print("2017-04-20")
f = now
#now()
wrapper = log(f)
wrapper()

偏函数

其实就是简化函数的参数,固定一部分参数

1. #为 **kw的模式,新生成一个int2的函数,基数为2
   int2 = functools.partial(int,base=2)
   print(int2('11111'))
   #为 *args,新生成一个比较大小的函数,在左侧加入固定参数
   maxAdd10 = functools.partial(max,10)
   print(maxAdd10(4,5))

2017-04-20 23:20:45 星期四

模块

一个.py的文件可称为一个模块,为了避免模块名冲突,加入了包名,在包中包含了一个__init__.py,称为包名的模板;

作用域

name 特殊变量,可以直接使用
__name 私有变量,不能在外部直接使用
_name 虽然可从外部访问,但应该避免
name 正常变量,可直接使用

安装第三方模块

1. pip install pillow
2. from PIL import image

面向对象编程

# 定义对象,后面的object表明该类是从哪个类继承下来的
>>>classStudent(object):
...def __init__(self,name,score):
...self.name = name
...self.score = score
...def print_score(self):
...print("%s:%s"%(self.name,self.score))
...
>>> bar =Student("list",59)
>>> bar.print_score()
list:59
## 不同对象的实例可以绑定不同的属性
>>> bar.score
59
>>> bar.age
Traceback(most recent call last):
File"<stdin>", line 1,in<module>
AttributeError:'Student'object has no attribute 'age'
>>> bar.age =10
>>> bar.age
10

继承与多态

与java类型:
class Animal(object):
class Dog(Animal):
Dog继承自Animal,并继承了所有父类的方法;
多态:如一个方法:def run(animal),可以带入animal及dog对象;

获取对象信息

注意:在不知道内部结构的时候才会采取setattr/getattr/hasattr方式取值或设置值,在已知结构的情况下,可以直接使用obj.get_attr/obj.attr来操作;

## 获取类型方式一
>>> type('str')
<class'str'>
>>> type('str')== str
True
## 获取类型方式二
>>> isinstance(123,int)
True
>>> isinstance('123',str)
True
## 对象拥有所有的属性与方法的集合
dir("123")
##是否包含属性或方法
hasattr(obj,"attrname")
## 类似于反射
getattr(obj,"attrname")
## 类似于反射
setattr(obj,"attrname")

类属性与实例属性

实例可以绑定绑定任意的属性;
类属性可被实例及类引用.

>>>
>>>classStudent(object):
... name ="class name"
## 类属性可被实例及类引用
>>> instance =Student()
>>> instance.name
'class name'
>>>Student.name
'class name'
##在实例中修改属性,在实例值改了,使用类调用时还为类属性
>>> instance.name="instance name"
>>> instance.name
'instance name'
>>>Student.name
'class name'
##删除实例属性后类属性会显示出来了
>>>del instance.name
>>> instance.name
'class name'

面向对象高级编程

classStudent(object):
# 限制可以加的属性及方法名
__slots__ =('age','name','set_age','set_name')
pass
def set_age(self, age):
self.age = age
student =Student()
# 可以给实例绑定任意的属性,这就是动态语言的优势,其它实例无法使用
student.age =20
print(student.age)
# 可以给实例绑定方法,给实例绑定的方法其它实例无法使用
student.set_age =MethodType(set_age, student)
student.set_age(50)
print(student.age)
print('------------------------------------------------------')
# 可以给类绑定属性,所有实例都可以使用,但类属性对实例来说是只读的,无法修改
Student.name ='zhangsan'
student2 =Student()
print(student2.name)
def set_name(self, name):
self.name = name
# 给类绑定方法,所有实例都可使用
Student.set_name = set_name
student3 =Student()
student3.set_name('lisi')
print(student3.name)
<pre style="background-color:#2b2b2b;color:#a9b7c6;font-family:'宋体';font-size:12.8pt;">
classStudent(object):
# 限制可以加的属性及方法名
__slots__ =('age','name','set_age','set_name')
pass
def set_age(self, age):
self.age = age
student =Student()
# 可以给实例绑定任意的属性,这就是动态语言的优势,其它实例无法使用
student.age =20
print(student.age)
# 可以给实例绑定方法,给实例绑定的方法其它实例无法使用
student.set_age =MethodType(set_age, student)
student.set_age(50)
print(student.age)
print('------------------------------------------------------')
# 可以给类绑定属性,所有实例都可以使用,但类属性对实例来说是只读的,无法修改
Student.name ='zhangsan'
student2 =Student()
print(student2.name)
def set_name(self, name):
self.name = name
# 给类绑定方法,所有实例都可使用
Student.set_name = set_name
student3 =Student()
student3.set_name('lisi')
print(student3.name)
</pre>

使用@property

# 将geeter方法作为property,将setter方法改为width.setter
classScreen(object):
@property
def width(self):
returnself._width
@width.setter
def width(self, width):
self._width = width
screen =Screen()
scren.width =100

多重继承

1. # 称之为MixIn模式
2. classClassName(,XXMixIn):

定制类

1. __str__ 用户打印
2. __init__ 初始化
3. __repr__ 调试打印
4. __iter__ 可使用for...in循环
5. __next__ 拿到循环的下一个值,直到退出
6. __getitem__ 拿到循环的指定索引值
7. __getattr__ 获取属性,可自定义

使用枚举类

# 两种枚举类的定义
@unique
classWeekend(Enum):
Sunday=0
Monday=1
# 所有成员
for name, member inWeekend.__members__.items():
print(name, member)
Month=Enum('Month',('Jan','Feb'))

异常处理

try:
　　print(test_method(0))
except BaseExceptionas e:
　　logging.exception(e)
finally:
　　print('finally')

文件操作

with open("D:/a.txt",'r', encoding='utf-8')as f:
f.read()
f.readline()
'大部分的文件操作都在os包下,少部分在shutil下,是对os的一个扩充'
print(os.path.abspath('.'))
print('---------列出所有的文件---------')
print([file for file in os.listdir('.')if os.path.isfile(file)and os.path.splitext(file)[1]=='.py'])

序列化与反序列化存入 file-like-object对象

'序列化与反序列化'
data = dict(name='张三')
with open('test.txt','wb')as file:
pickle.dump(data, file)
with open('test.txt','rb')as file:
print(pickle.load(file))
student =Student('zhangsan',10)
# 将对象序列化字符串
print(json.dumps(student,default=lambda obj: obj.__dict__))
# 将字符串反序列化为dict,指定object_hook参数将dict转换为指定对象
print(json.loads(json.dumps(student,default=lambda obj: obj.__dict__)))

多进程与多线程

在window系统中,多进程与多线程可能会出错,建议使用linux与mac系统完成此类操作

import os
from multiprocessing importProcess
def run_process(name):
print('创建了一个子进程%s(%s)'%(name, os.getpid()))
print('进程号为: %s'% os.getpid())
process =Process(target=run_process, args=('test',))
process.start()
process.join()
print('子进程结果运行')
# 不可以通过队列Queue来执行一部分操作

线程与多线程

import threading
import time
def loop(name):
print('Thread %s is running'% threading.current_thread().name)
n =0
while n <5:
n = n+1
print('Thread %s is running'% threading.current_thread().name)
time.sleep(1)
print('Thread %s is end'% threading.current_thread().name)
print('Thread %s is running'% threading.current_thread().name)
thread1 = threading.Thread(target=loop, args=('test-thread',))
thread1.start()
thread1.join()
print('Thread %s is end'% threading.current_thread().name)
## python的多线程由于全局锁的机制,无法有效利用多核CPU的优势,如果要使用多核,请使用多进程