python简单学习大纲

数据类型

Number（数字）
String（字符串）
List（列表）
Tuple（元组）
Set（集合）
Dictionary（字典）
六个标准数据类型中：
不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。

list列表的一些重要方法

list.append(x) 把一个元素添加到列表的结尾，相当于 a[len(a):] = [x]。
list.extend(L) 通过添加指定列表的所有元素来扩充列表，相当于 a[len(a):] = L。
list.insert(i, x) 在指定位置插入一个元素。第一个参数是准备插入到其前面的那个元素的索引，例如 a.insert(0, x) 会插入到整个列表之前，而 a.insert(len(a), x) 相当于 a.append(x) 。
list.remove(x) 删除列表中值为 x 的第一个元素。如果没有这样的元素，就会返回一个错误。
list.pop([i]) 从列表的指定位置移除元素，并将其返回。如果没有指定索引，a.pop()返回最后一个元素。元素随即从列表中被移除。（方法中 i 两边的方括号表示这个参数是可选的，而不是要求你输入一对方括号，你会经常在 Python 库参考手册中遇到这样的标记。）
list.clear() 移除列表中的所有项，等于del a[:]。
list.index(x) 返回列表中第一个值为 x 的元素的索引。如果没有匹配的元素就会返回一个错误。
list.count(x) 返回 x 在列表中出现的次数。
list.sort() 对列表中的元素进行排序。
list.reverse() 倒排列表中的元素。
list.copy() 返回列表的浅复制，等于a[:]。

print()、input()函数

print("hello,I'm python！")#sting需要双引号或单引号
print('hello,I\'m python！')#单引号遇特殊字符需要"\"反斜杠转义

input()输入

a=input("输入")
print(a)

输入1
1

读和写文件

#open()函数打开文件、w写，r只读
file=open("file.tex",'w')
file.write('hello python!')#写入内容
file.close()

#查看文件内容
with open("file.txt", 'r') as f:
    a = f.read() 
print(a)

hello python!
hello python!

# 打开一个文件
f = open("file.txt", 'r')

str = f.read()
print(str)

# 关闭打开的文件
f.close()

hello python!
hello python!

f.readline()只读一行，f.readlines()读取多行

file= open("file.txt", "w")
file.write( "hello python!\nhello python!\n" )#\n换行
file.close()

# 打开一个文件
f = open("file.txt", "r")

str = f.readline()#f.readline()只读一行
print(str)

# 关闭打开的文件
f.close()

hello python!

f = open("file.txt", "r")

str = f.readlines()#f.readlines()读取多行
print(str)

# 关闭打开的文件
f.close()

['hello python!\n', 'hello python!\n']

错误处理try / except语句。

x = int(input('输入一个数字：'))

输入一个数字：a



---------------------------------------------------------------------------

ValueError                                Traceback (most recent call last)

<ipython-input-1-d600c141aeb2> in <module>
----> 1 x = int(input('输入一个数字：'))


ValueError: invalid literal for int() with base 10: 'a'

try:
    x = int(input('输入一个数字：'))
except:
    print('您输入的不是数字，请再次尝试输入！')

输入一个数字：a
您输入的不是数字，请再次尝试输入！

运算符

print(1+2)#+加 
print(1-2)#-减 
print(1*2)#*乘 
print(1/2)#/除 
print(1%2)#%取模 返回除法的余数
print(2**3)#**幂 ,2的3次方
print(5//2)#//取整除 

3
-1
2
0.5
1
8
2

"=="和"is"的区别

一个变量含有三个属性：
值 value
地址 id
类型 type
==对应value值
is对应地址id

#只有数值型和字符串型的情况下，a is b才为True，当a和b是tuple，list，dict或set型时，a is b为False
a=1
b=1
print(a==b)
print(a is b)
a1=(0,1,2)
a2=(0,1,2)
print(a1==a2)
print(a is a2)

True
True
True
False

循环

#while
a=5
while a>0:#为True,进入循环，为False跳出循环
    a=a-1
    print('a>0')

a>0
a>0
a>0
a>0
a>0

#for循环迭代,遍历列表
list=[1,2,3,4,5]
for i in list:
    print(i)

1
2
3
4
5

#if条件语句
a=5
b=10
if b>a:
    print('b>a')
elif b==a:
    print('b=a')
else:
    print('b<a')

b>a

#循环和条件语句可以互相嵌套
x=5
while x>0:
    x=x-1
    if x>2:       
        print('x>2')        
    print('x>0')

x>2
x>0
x>2
x>0
x>0
x>0
x>0

for i in 'hello python!':
    if i== '!':
        continue#continue跳过当前继续循环
    else:
        print(i,end=' ')#end是print（）中的一个参数，可选择结尾输入' '空格

h e l l o   p y t h o n 

for i in 'hello python!':
    if i== 'p':        
        break#break跳出当前循环
    else:
        print(i,end='')
       

hello 

def 定义函数

我们可以定义一个特定功能的函数然后调用其。函数内可包含三类参数（farg、*args，**kwargs）：
farg：表示正常的参数传输，第一个值；
*args：除farg后，表示任何多个无名参数，是一个list或tuple；
**kwargs：表示关键字参数，是一个dict；
也可分为以下几种类型：
必需参数
关键字参数
默认参数
不定长参数
#设置a和b为必选参数，设置c和d为默认参数
#如果不需要改变默认参数，不用传入默认参数，必选参数一定要传入，且在默认参数的前面
#需要改变默认参数时，传入默认参数即可
#不要要改变的默认参数不用传入；如果没有传入默认参数的名称，则按照默认参数的顺序进行传递
#如果传入默认参数的名称，即改变该默认参数的值。

def fun(a,b,c=2,d=3):#定义一个名为fun的函数，用它做一些运算。
    x=a*b+c+d
    print(x)

#调用名为fun的函数，必须为a、b必选参数赋值
fun(2,3)

11

def fun(a,b,c=2,d=3):
    x=a*b+c+d
    return x#可用return返回值达到print的效果
fun(2,3)

11

全局变量和局部变量

a1=2#全局变量,函数内可以直接调用
def fun(a,b,c=2,d=3):#定义一个名为fun的函数，用它做一些运算。
    x=a*b+c+d
    print(x)
fun(a1,3)    

11

fun(c,3)#c是函数内定义的局部变量，不可调用

---------------------------------------------------------------------------

NameError                                 Traceback (most recent call last)

<ipython-input-40-31d7b775ba90> in <module>
----> 1 fun(c,3)


NameError: name 'c' is not defined

c=None

def fun(a,b,d=3):#定义一个名为fun的函数，用它做一些运算。
    global c#通过在全局变量定义+global方法将局部变量变为全局变量
    c=1
    x=a*b+c+d
    print(x)
fun(1,2)#注意：变量不能同时作为global变量和函数之间传递的变量

6

运行函数后，局部变量已经转换为了全局变量

print(c)

1

类，面向对象object

#可通过class 定义一个类，其中包含很多属性
#如一个人类,有名字，性别等等
class human:
    name='小明'
    sex='m'
    
        

#可以调用这个类进行实例化,获得其属性
A=human()
A.name

'小明'

class human:
    def __init__(self,name,sex):#可用__init__（）方法为类设置固有属性参数
        self.n=name#需要用到self代表调用私有属性
        self.s=sex
    def fun(self,a,b,c=2,d=3):#一个类可以包含多个函数
        x=a*b+c+d
        return x
       

A1=human('小明','m')#需要为类的固有属性赋值参数

A1.n#访问已经被定义成n的‘name'属性

'小明'

lanmda匿名函数、map

# 可用lanmda定义只使用一次的简单函数
add = lambda x,y,z:x+y+z
print(add(1,2,3))

6

# 可将lanmada函数赋值给其他函数,如之前human类中定义的fun
A1.fun(add(1,2,3),add(1,2,3))

41

map() 函数：
参数：
function ----> 函数
iterable ----> 一个或多个序列
在python3里面，map()的返回值是iterators,而不是list， 所以想要使用，需将iterator 转换成list
Python 2.x 版本返回的是列表
Python 3.x 版本返回的是迭代器

print(list(map(add,[1,2,3],[1,2,3],[1,2,3])))

[3, 6, 9]

排序方法，sort()、sorted(),reverse(),reversed()

reverse()与sort()的使用方式一样，无需参数，无返回值，二者均是列表的方法，调用后会改变原列表。
reversed()与sorted()的调用方式相同，需要给出参数，参数可以是列表，元组，字符串，调用后不改变原对象。

#sort()字典、列表,reverse参数False正序、True逆序
list1=[9,2,7,4,1]
list1.sort(reverse=False)
print(list1)
list1.sort(reverse=True)
print(list1)

[1, 2, 4, 7, 9]
[9, 7, 4, 2, 1]

# sorted()是python的内置函数
d={'a':1,'c':3,'b':2}
print(sorted((d.keys()),reverse=False))#key排序
print(sorted((d.values()),reverse=False))#值排序

['a', 'b', 'c']
[1, 2, 3]

list2=[1,7,3,4]
print(list2)
list2.reverse()#reverse()翻转列表
print(list2)

[1, 7, 3, 4]
[4, 3, 7, 1]

浅拷贝、深拷贝

主要针对内存、针对可变对象（列表、字典）
对于不可变对象（字符串、元组）
无论是浅拷贝还是深拷贝内存地址都不变
分类：
浅拷贝相当于引用，会收所复制的对象影响
深拷贝直接将其复制下来，之后不受复制对象影响

#浅拷贝后使用同一个id内存，被赋值的b也会做相同的改变
l=[0,1,2,3]
l1=l#赋值浅拷贝
print(l)
print(id(l))
print(l1)
print(id(l1))
l.append(1) #添加元素后一起改变
print(l)
print(l1)

[0, 1, 2, 3]
2186494700168
[0, 1, 2, 3]
2186494700168
[0, 1, 2, 3, 1]
[0, 1, 2, 3, 1]

#调用copy模块进行浅拷贝,没有拷贝子对象，所以原始数据改变，子对象会改变
import copy
l2=[1,2,3,[1,2,3]]
l22=copy.copy(l2)
print(l2)
print(id(l2))
print(l22)
print(id(l22))
l22.append(1) #添加元素后一起改变
print(l2)
print(l22)
l2[3].append(1) #里面的子对象被改变了,所以依然是浅拷贝
print(l2)
print(l22)

[1, 2, 3, [1, 2, 3]]
2186510101064
[1, 2, 3, [1, 2, 3]]
2186510285128
[1, 2, 3, [1, 2, 3]]
[1, 2, 3, [1, 2, 3], 1]
[1, 2, 3, [1, 2, 3, 1]]
[1, 2, 3, [1, 2, 3, 1], 1]

# 使用deep.copy（）进行深拷贝
l3=[1,2,3,[1,2,3]]
l4=copy.deepcopy(l3)
print(l3)
print(id(l3))
print(l4)
print(id(l4))
l3[3].append(1)
print(l3)
print(id(l3))
print(l4)
print(id(l4))

[1, 2, 3, [1, 2, 3]]
2186511559816
[1, 2, 3, [1, 2, 3]]
2186510137928
[1, 2, 3, [1, 2, 3, 1]]
2186511559816
[1, 2, 3, [1, 2, 3]]
2186510137928

迭代器与生成器

迭代器有两个基本的方法：iter() 和 next()。
字符串，列表或元组对象都可用于创建迭代器

#iter()函数
list=[1,2,3,4]
it = iter(list)    # 创建迭代器对象
for x in it:
    print (x, end=" ")

1 2 3 4 

# next() 
import sys         # 引入 sys 模块
list=[1,2,3,4]
it = iter(list)    # 创建迭代器对象
while True:
    try:
        print (next(it))
    except StopIteration:
        pass

1
2
3
4

把一个类作为一个迭代器使用需要在类中实现两个方法 iter() 与 next() 。

class MyNumbers:
    def __iter__(self):
        self.a = 1
        return self
 
    def __next__(self):
        x = self.a
        self.a += 1
        return x
 
myclass = MyNumbers()
myiter = iter(myclass)
 
print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))

1
2
3
4
5

生成器

在 Python 中，使用了 yield 的函数被称为生成器（generator）。
跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。
在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。
调用一个生成器函数，返回的是一个迭代器对象。
以下实例使用 yield 实现斐波那契数列：

import sys
 
def fibonacci(n): # 生成器函数 - 斐波那契
    a, b, counter = 0, 1, 0
    while True:
        if (counter > n): 
            return
        yield a
        a, b = b, a + b
        counter += 1
f = fibonacci(10) # f 是一个迭代器，由生成器返回生成
 
while True:
    try:
        print (next(f), end=" ")
    except StopIteration:
        pass

0 1 1 2 3 5 8 13 21 34 55 

装饰器

定义函数后，再次返回函数作为参数，用函数作为参数为其他函数添加功能
高阶函数+嵌套函数=装饰器

def fun(a):
    return a+2
    
def fun1(a,b):
    return a+b

print(fun(fun1(1,2)))#函数作为参数返回

5

def f(func):#定义装饰器函数，内部需要一个参数返回函数
    def f1():#装饰器内部函数
        func()#需要返回这个参数函数,执行的是f3()函数
        print("world")
        print("how are you?") 
    return f1#返回内部定义的函数 
def f3():
    print("hello")
f3()

hello

f3=f(f3)#把定义好的f3函数作为参数传回f装饰器函数中

f3()
#对于只能输出hello的函数，通过f函数作为装饰器使其增加输出world、how are you?功能

hello
world
how are you?

可通过@f语法糖的形式简化函数参数赋值 (@A)=（f3=f(f3))

def f(func):#定义装饰器函数，内部需要一个参数返回函数
    def f1():#装饰器内部函数
        func()#需要返回这个参数函数,执行的是f3()函数
        print("world")
        print("how are you?") 
    return f1#返回内部定义的函数
@f
def f3():
    print("hello")
f3()

hello
world
how are you?

多任务（线程、进程、协程）

进程、线程切换由系统决定，协程程序员自己决定
进程中有线程，线程中有协程
进程是系统进行资源分配调度的最小的独立单位
线程是进程的实体，是cpu调度和分派的基本单位
协程也是线程，微线程，自带cpu上下文，是比线程更小的执行单元

从计算机硬件角度：
计算机的核心是CPU，承担了所有的计算任务。
一个CPU，在一个时间切片里只能运行一个程序。
从操作系统的角度：
进程和线程，都是一种CPU的执行单元。
进程：表示一个程序的上下文执行活动（打开、执行、保存…）
线程：进程执行程序时候的最小调度单位（执行a，执行b…)
一个程序至少有一个进程，一个进程至少有一个线程。

并行 和 并发：
并行：多个CPU核心，不同的程序就分配给不同的CPU来运行。可以让多个程序同时执行。
cpu1 -------------
cpu2 -------------
cpu3 -------------
cpu4 -------------
并发：单个CPU核心，在一个时间切片里一次只能运行一个程序，如果需要运行多个程序，则串行执行。
cpu1　　----　　----
cpu1 　　　----　　----

多进程/多线程：
表示可以同时执行多个任务，进程和线程的调度是由操作系统自动完成。
进程：每个进程都有自己独立的内存空间，不同进程之间的内存空间不共享。
进程之间的通信有操作系统传递，导致通讯效率低，切换开销大。
线程：一个进程可以有多个线程，所有线程共享进程的内存空间，通讯效率高，切换开销小。
共享意味着竞争，导致数据不安全，为了保护内存空间的数据安全，引入"互斥锁"。
一个线程在访问内存空间的时候，其他线程不允许访问，必须等待之前的线程访问结束，才能使用这个内存空间。
互斥锁：一种安全有序的让多个线程访问内存空间的机制。

Python的多线程：
GIL 全局解释器锁：线程的执行权限，在Python的进程里只有一个GIL。
一个线程需要执行任务，必须获取GIL。
好处：直接杜绝了多个线程访问内存空间的安全问题。
坏处：Python的多线程不是真正多线程，不能充分利用多核CPU的资源。
但是，在I/O阻塞的时候，解释器会释放GIL。
所以：
多进程：密集CPU任务，需要充分使用多核CPU资源（服务器，大量的并行计算）的时候，用多进程。 multiprocessing
缺陷：多个进程之间通信成本高，切换开销大。
多线程：密集I/O任务（网络I/O，磁盘I/O，数据库I/O）使用多线程合适。
threading.Thread、multiprocessing.dummy
缺陷：同一个时间切片只能运行一个线程，不能做到高并行，但是可以做到高并发。
协程：又称微线程，在单线程上执行多个任务，用函数切换，开销极小。不通过操作系统调度，没有进程、线程的切换开销。
genvent，monkey.patchall
多线程请求返回是无序的，那个线程有数据返回就处理那个线程，而协程返回的数据是有序的。
缺陷：单线程执行，处理密集CPU和本地磁盘IO的时候，性能较低。处理网络I/O性能还是比较高.