python自学笔记【基础L1】

一 基础数据类型

1. 整数 int 1,2,3....
2. 浮点数 float 3.5 小数
3. 字符串 str
4. 布尔值 bool true/false

# 强制类型转换
int("1") >> 1
str(1) >> "1"
float(2) >> 2.0
bool("fankers") >> True

二 变量

定义：数字 字母 下划线，不能以数字开头

三 序列

序列包含

• 字符串

"fankers"

• 列表

["fankers","xxshare"]

• 元组

("fankers","xxshare")

基本操作

1. 成员关系操作符
2. 连接操作符
3. 重复操作符
4. 切片操作符

四 条件 循环

if elif else

if condition :
    print("condition"+condition)
elif condition2:
    print("condition2"+condition2)
else:
    print("else condition")

for循环

for i in range(1,10):
    print(i)

while

while True:
    print("this is while")

break /continue 用来终止或者跳出循环体

print 占位替换 print(“this is test %s” %(“fankers”))

五 映射字典

定义和常用操作

# 定义
aa = {}
# 新增
aa['name'] = "fankers"

推倒式

alist = []
for i in range(1,10):
	if i%2 == 0:
		alist.append(i * i)
print(alist)

blist = [i*i for i in range(1,11) if i%2 == 0]	
print(blist)
# 命令执行
>>> blist = [i*i for i in range(1,11) if i%2 == 0]      
>>> print(blist)
[4, 16, 36, 64, 100]


clist = {i:0 for i in range(1,11)}
print(clist)
# 命令执行
>>> clist = {i:0 for i in range(1,11)}
>>> print(clist)
{1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0}

六 文件输入输出

# 写入文件
file1 = open("name.txt",'w') #默认以只读的方式打开文件
file1.write("fankers")
file1.close()# 关闭文件

# 读取文件
file2 = open("name.txt")
file2.read()
file2.close()

# 新增
file3 = open("name.txt",'a')
file3.write("xxshare")
file3.close()

# 读取一行
file4 = open("name.txt")
file4.readline()
file4.close()

# 逐行处理
file5 = open("name.txt")
for i in file5.readlines():
    print(i)

# 移动文件指针
file6 = open("name.txt")
print(file6.tell())

file6.read(1)
print(file6.tell())

file6.seek(0) #seek 第一个参数偏移量
print(file6.tell())

七 错误和异常

try:

except ValueError:
    print("this is exception")
else:
    print("success")
finally:
    print("this is finally")

常用内置错误

1. 使用未定义变量 (NameError: name 'a' is not defined),
2. 访问列表不存在的索引 IndexError: list index out of range 
3. 访问字典不存在的关键字观察系统提示 KeyError: 'long'
4. ValueError 值类型不匹配

自定义抛出异常

raise MyError('异常异常...')

八 函数

定义

可变长参数

def howlong(first, *other):
    return 1+len(other)

print(howlong(1,2,3))

作用域

var1 = 123

def func():
    global var1
    var1 = 456
    print(var1)

func()
print(var1)
456
123

函数迭代器和生成器

• iter

alist = [1,2,3]
it1 = iter(alist)
print(next(it1))
print(next(it1))
print(next(it1))
print(next(it1))

• range

for i in range(1,10,2):
    print(i)

• 自定义生成器 带yield的迭代器叫做生成器

def frange(start, stop, step):
    x = start
    while x < stop:
        yield x
        x+=step

for i in frange(10,13,0.5):
    print(i)

# 输出结果
10
10.5
11.0
11.5
12.0
12.5

Lambda表达式

def True(): return True
lambda : True


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

lambda x,y : x+y

内置函数（常用）

filter() map() reduce() zip()等 
参见官方文档

filter()
list1 = [1,2,3,5,6,7]
print(list(filter(lambda x: x>2 ,list1)))

map()
list2 = [1,2,3,5,6,7]
print(list(map(lambda x: x+1,list2)))

reduce()
from functools import reduce
print(reduce(lambda x,y: x+y,[2,3,4],1))
((1+2)+3)+4 => 10 

for i in zip([1,2,3],[4,5,6]):
    print(i)

# 输出结果
(1, 4)
(2, 5)
(3, 6)

# 对字典的key和value对调
dicta = {'name':'fankers','age':18}
print(dict(zip(dicta.values(),dicta.keys())))

# 输出结果
{'fankers': 'name', 18: 'age'}

闭包函数

def sum(a):
    def add(b):
        return a+b
    return add
# add 函数的名称或者函数的饮用
# add() 函数的调用
num2 = sum(2)
print(type(num2)) 返回值是 function

#计数器：
def counter():
    cnt = [0]
    def add_one():
        cnt[0] += 1
        return cnt[0]
    return add_one
num1 = counter()
print(num1())
print(num1())
print(num1())
print(num1())
print(num1())


# 传参
def counter(FIRST = 0):
    cnt = [FIRST]
    def add_one(STEP = 1):
        cnt[0] += STEP
        return cnt[0]
    return add_one
num1 = counter()
num5 = counter(5)
print(num1())
print(num1())
print(num1())
print(num5())
print(num5(5))

# 输出结果
1
2
3
6
11

装饰器

• 不带参数的装饰器

import time
def timmer(func):
    def wrapper():
        start_time = time.time()
        func()
        end_time = time.time()
        print("运行时间是 %s 秒" %(end_time - start_time))
    return wrapper


@timmer
def i_can_sleep():
    time.sleep(3)

i_can_sleep()

# 输出结果
运行时间是 3.002596139907837 秒

• 带参数的装饰器

def newtips(argv):
    def tips(func):
        def nei(a,b):
            print('start %s %s' %(argv,func.__name__))
            func(a,b)
            print('end')
        return nei
    return tips

@newtips('add_module')
def add(a,b):
    print(a + b)
add(1,2)

@newtips('sub_module')
def sub(a,b):
    print(a-b)

sub(4,2)

# 输出结果
3
end
start sub_module sub
2
end

上下文管理器

fd = open("name.txt")
try:
    for line in fd:
        print(line)
finally:
    fd.close()

with open('name.txt') as f:
    for line in i:
        print(line)

九 模块

• 导入模块

# 方式1
import time
time.slee(2)

# 方式2
import time as t
t.sleep(2)

# 方式3
from time import sleep
sleep(2)

• 模块定义

def print_me():
    print('me')

print_me()

# 输出结果
me

导入
import mymod
mymod.print_me()

# 输出结果
me

十 规范

autopep8

十一 面向对象 (封装 继承 多态)

• 类与实例

class Player(): #定义一个类
    def __init__(self,name,hp):# 实例化类之后执行
        self.name = name
        self.hp = hp
    def print_role(self): # 定一个方法
        print('%s : %s' %(self.name,self.hp))

player1 = Player("fankers",100) # 类的实例化
player1.print_role()

• 类的封装

class Player():
    def __init__(self,name,hp,occu):
        #self.name = name # 外部可以直接访问
        self.__name = name # 外部不能直接访问
        self.hp = hp
        self.occu = occu

    def print_role(self):
        print('%s : %s : %s' %(self.__name,self.hp,self.occu))

    def updateName(self,newname):
        self.__name = newname

class Monster():
    '定义一个怪物类'
    pass

player1 = Player("fankers",100,'war')
player1.print_role()

# 修改名称
player1.updateName("xxshare")

#player1.name = "ermao"
player1.print_role()

• 类的继承

class Monster():
    '定义一个怪物类'
    def __init__(self,hp = 100):
        self.hp = hp
    def run(self):
        print("移动一个位置")
    def whoami(self):
        print("我是怪物的父类")

class Animals(Monster):
    '普通的怪物'
    def __init__(self,hp):
        # self.hp = hp
        super().__init__(hp)

class Boss(Monster):
    'Boss类怪物'
    def __init__(self,hp = 1000):
        super().__init__(hp)
    def whoami(self):
        print("喔是怪物喔怕谁")
    
a1 = Monster(200)
print(a1.hp)
a1.run()

a2 = Animals(10)
print(a2.hp)
a2.run()

a3 = Boss(800)
a3.whoami()

print('a1的类型：%s' %(type(a1)))
print('a2的类型：%s' %(type(a2)))
print('a3的类型：%s' %(type(a3)))

print(isinstance(a1,Monster)) # 判断类型的所属关系

• 自定义with语句

class TestWith():
    def __enter__(self):
        print('run')
    def __exit__(self,exec_type,exec_val,exec_cb):
        if exec_cb is None:
            print('正常结束')
        else:
            print('异常了%s' %exec_cb)

with TestWith():
    print('with test')
    raise NameError('testNameError')

# 输出结果
run
with test
异常了<traceback object at 0x10fbe04b0>
Traceback (most recent call last):
  File "/Users/fangkeke/PythonProject/with_test.py", line 12, in <module>
    raise NameError('testNameError')
NameError: testNameError

十二 多线程编程

定义

import threading
import time
from threading import current_thread

def myThread(arg1,arg2):
    print(current_thread().getName(),'start')
    print('%s %s' %(arg1,arg2))
    time.sleep(1)
    print(current_thread().getName(),'stop')

for i in range(1,6):
    # t1 = myThread(i,i+1)
    t1 = threading.Thread(target=myThread,args=(i,i+1))
    t1.start()

print(current_thread().getName(),'end')

# 输出结果
Thread-1 start
1 2
Thread-2 start
2 3
Thread-3 start
3 4
Thread-4 start
4 5
Thread-5 start
5 6
MainThread end
Thread-1 stop
Thread-3 stop
Thread-2 stop
Thread-5 stop
Thread-4 stop


子父线程依赖

import threading
from threading import current_thread

class MyThread(threading.Thread):
    def run(self):
        print(current_thread().getName(),'start')
        print('run')
        print(current_thread().getName(),'stop')

t1 = MyThread()
t1.start()
t1.join()

print(current_thread().getName(),'end')

Thread-1 start
run
Thread-1 stop
MainThread end

• 多线程应用 - 生产者消费者问题

from threading import Thread,current_thread
import time
import random
from queue import Queue

# 队列长度
queue = Queue(5)

# 生产者
class ProducerThread(Thread):
    def run(self):
        name = current_thread().getName()
        nums = range(100)
        global queue
        while True:
            num = random.choice(nums)
            queue.put(num)
            print('生产者 %s 生产了 %s' %(name,num))
            t = random.randint(1,3)
            time.sleep(1)
            print('生产者 %s 睡眠了 %s秒' %(name,t))

# 消费者
class CustomerThread(Thread):
    def run(self):
        name = current_thread().getName()
        global queue
        while True:
            num = queue.get()
            queue.task_done() # 线程等待线程同步
            print('消费者 %s 消费了数据 %s' %(name,num))
            t = random.randint(1,3)
            time.sleep(1)
            print('消费者 %s 睡眠了 %s秒' %(name,t))


p1 = ProducerThread(name = "p1")
p1.start()

c1 = CustomerThread(name = 'c1')
c1.start()

c2 = CustomerThread(name = 'c2')
c2.start()

感谢 极客时间-尹会生老师的教程