python课程笔记

一、python

1.计算机组成

CPU：处理指令、运算数据
内存：临时存储CPU运算的数据

2.了解python

2.1、特点

①简单、易学
②开源、免费
③应用领域广泛：网络爬虫、数据分析、人工智能、机器学习、web开发、自动化测试、自动化运维

2.2、版本号

·python 2.x
·python 3.x
python 3.5
python 3.6
python 3.7

2.3、python基础学习路线

二、python入门

2.1、环境搭建

2.1.1、python解释器

作用：运行文件
python 解释器的种类
①CPython，C语言开发的解释器
②IPython，基于CPython的一种交互式解释器
③其他解释器
PYPY，基于Python语言开发的解释器
Jython，运行在Java平台的解释器，直接把Python代码编译成Java字节码执行
IronPython，运行在微软.Net平台上的Python解释器，可以直接把Python代码编译成.Net的字节码
课程中使用的解释器：CPython

2.1.2、下载python解释器

下载地址：https://www.python.org/downloads/release/python-372/

2.1.3、PyCharm

PyCharm 是一种Python IDE（集成开发环境），带有一整套可以帮助用户在使用Python语言开发时提高其效率的工具，内部集成的功能如下：
PyCharm分为专业版（professional）和社区版(community)
下载链接：http://www.jetbrains.com/pycharm/download/#section=windows

PyCharm交互式开发：点击左下角Python Control

2.1.4、注释

注释分为两类：单行注释和多行注释

单行注释：#单行注释 ctrl+/
多行注释：“”“多行注释 “”” 或者 ‘’‘多行注释 ‘’’(6个单引号或6个双引号)

---

2.2、变量

变量就是存储数据的时候当前数据所在内存地址的名字
a=1
b=1.1

1、标识符的命名规则:
①由数组、字母、下划线组成
②不能以数字开头
③不能使用内置关键字
④严格区分大小写

2、命名习惯：
①见名知义
②大驼峰
③小驼峰
④下划线

---

2.3、debug

所谓bug，就是程序中的错误。

debug工具使用步骤：①打断点②debug调试

1、打断点
单击行号位置

2、debug调试
以debug方式运行

---

2.4、数据类型

7种：

检测数据类型用type（数据）
字符串数据带引号
a=‘myname’
print（type（a））

list列表 b=[10,20,30]
tuple 元组 b=(10,20,30)
set集合 b={10,20,30}
dict字典 b={'id':'123' , 'name':'myname'} 与键值对相似

---

2.5、输出

格式化输出
格式化输出
f-字符串
print的结束符

1、格式化输出

name='myname'
print('我的名字是%s，你好'  %name)

%.2f 小数点后面保留两位小数

%03d 3位数，不足的话以0补全，超出的原样输出，用以实现数字对齐功能

%（id+1,name）用以实现多个变量的输出

%s功能比较强大，可以输出整型和浮点型

f 格式化字符串(推荐使用) f’{表达式}’

name = 'myname'
print(f'我叫{name}')

'''
python print对齐
1、使用%格式按列对齐打印输出
2、使用format()函数按列对齐打印输出
3、使用f-string按列对齐打印输出
4、使用字符串函数按列对齐打印输出，ljsut,rjust,center,
'''
# 使用%格式按列对齐打印输出  *定义宽度 -代表左对齐
print('*'*10+'%格式'+'*'*10)
print('正常输出====%s===='%('name'))
print('左对齐，name占8位====%-*s===='%(8,'name'))
print('name占8位====%*s===='%(8,'name'))
# format :<n左对齐   :>n右对齐   :^n居中对齐  n是宽度  写在{}里面
print('*'*10+'format格式'+'*'*10)
print("正常输出===={key}====".format(key='name'))
print("8位左对齐===={:<8}====".format('name'))
print("8位左对齐===={key:<8}====".format(key='name'))
print("8位居中对齐===={key:^8}====".format(key='name'))
# f和format类似 :>n右对齐 :^n居中对齐 n是宽度 写在{}里面 默认空格填充，指定填充内容加在冒号后面添加字符
print('*'*10+'f格式'+'*'*10)
key = 'name'
print(f"8位左对齐{
     key:<8}")
print(f"8位左对齐，用字符0填充{
     '111':0<8}")
# 字符串函数ljust rjust center zfill
print('*'*10+'字符串函数格式'+'*'*10)
print('左对齐20位'.ljust(20,'-'))
print('右对齐20位'.rjust(20,'-'))
print('居中对齐20位'.center(20,'-'))
print('20位，不足以0填充'.zfill(20))

'''
**********%格式**********
正常输出====name====
左对齐，name占8位====name    ====
name占8位====    name====
**********format格式**********
正常输出====name====
8位左对齐====name    ====
8位左对齐====name    ====
8位居中对齐====  name  ====
**********f格式**********
8位左对齐name
8位左对齐，用字符0填充11100000
**********字符串函数格式**********
左对齐20位--------------
--------------右对齐20位
------居中对齐20位-------
000000000020位，不足以0填充
'''

2、转义字符

print(‘我叫/n张三’)

3、print结束符
print('输出'，end="\n") 默认结束符号是\n, end=可以是其他的结束符号

---

2.6、输入

1、语法

a = input("提示信息")

特点：
①当程序执行到input，等待输入，输入完成之后再向下执行
②input接受到用户输入后，一般存储到变量，方便使用
③input会把接收到的数据都当作字符串处理

---

2.7、数据类型转换

数据类型转换函数：

# ord:将字符转换为ASCII编码
int_1 = ord('m')
int_2 = ord('n')
int_3 = ord('你') 
print(int_1, int_2, int_3)  # 109 110 20320

# chr:将整数转换为Unicode字符
str_1 = chr(109)
str_2 = chr(110)
print(str_1, str_2) # m n

# bin:将十进制转换为二进制 0b是二进制符 bin输出的是字符串， 字符串是不能使用左移右移的
bin_1 = bin(16)
print(bin_1, type(bin_1))  # 0b10000 str 

# oct:十进制转换为八进制，输出字符串
print(oct(100)) # 0o144

# hex:十进制转换为十六进制
print(hex(100))  # 0x64

# <<左移  >>右移
# 16左移两位
16<<2
print(16<<2)  # 64
print(0b10000<<2)  # 64
# print(bin_1<<2) # 会报错字符串不能位移

# int(x, base) 其他进制转换为十进制， base代表进制数，x是字符串
# 0b:二进制
# 0x:十六进制
# 0o:八进制
print(int('0b10000', 2))  # 16
print(int('10000', 8))  # 4090
print(int('10000', 16)) # 65536

# format也可以进行格式抓换
print('十六进制转换为二进制', format(0x10, '0b'))  # 十六进制转换为二进制 10000
print('十进制转换为二进制', format(10, '0b')) # 十进制转换为二进制 1010
print('二进制转换为十六进制', format(0b1000000000, '0x'))  # 二进制转换为十六进制 200

# eval其他进制转换为十进制
print('八进制转换成十进制', eval('0o10000')) # 八进制转换成十进制 4096

# eval可以将字符串转换成表达式或函数调用
def test_1():
    return 'test_1'

def test_2():
    return 'test_2'

num = 2
print(eval('test_' + str(num) + '()'))  # test_2
print(eval('num + 3')) # 5

---

2.8、运算符

运算符的分类（五大类）：
算术运算符
赋值运算符
复合赋值运算符
比较运算符
逻辑运算符

1、算术运算符

2、赋值运算符
多个变量赋值

a,b,c = 1,2,'ccc'

多个变量赋相同值

a=b=1

3、复合赋值运算符

4、比较运算符（关系运算符）

5、逻辑运算符

（a<b）and（b<c）

数字之间的逻辑运算：
and运算符，只要有一个值为0，则结果为0，否则结果为最后一个非0数字
or运算符，只有所有值为0结果才为0，否则结果为第一个非0数字

---

三、流程控制

3.1、条件语句

1、if语法
多重条件

if  条件1：
		条件成立执行的代码片段1
		条件成立执行的代码片段2
		。。。。。。
else 条件2:
		条件不成立执行的代码1
		条件不成立执行的代码2
		。。。。。。
。。。。。。
else:
		条件不成立执行的代码1
		条件不成立执行的代码2

if   a>b:
			print('a>b')

if嵌套

if  条件1：
		条件成立执行的代码片段1
		条件成立执行的代码片段2
		。。。。。。
		if  条件2：
				条件成立执行的代码片段1
				条件成立执行的代码片段2

注意：条件成立执行带缩进的代码，不带缩进这不属于if语句

2、三目运算符
语法：
条件成立的表达式 if 条件 else 条件不成立执行的表达式

a+1  if  a>b  else  b+1

---

3.2、随机数

import  random
random.randint(0,10)

---

3.3、循环

while循环和for循环

1、while循环

while    条件1：
		条件成立代码片段1
		条件成立代码片段2
		。。。。。。
		while    条件2：
				条件成立代码片段1
				条件成立代码片段2
				。。。。。。
else ：
		循环正常结束之后执行的代码 

else当循环正常结束之后执行的代码
如果用break终止循环，else代码块不执行
如果用continue终止循环，else代码块正常执行

i = 0
while i<5:
		print('')
		i+=1

2、break和continue
break终止循环
continue终止当前循环，执行下一次循环

3、for循环

for  临时变量   in  序列：
		重复执行的代码1
		重复执行的代码2
		。。。。。。
else :
       循环正常结束之后执行的代码块

3.4、迭代器Iterator和生成器generator

3.4.1、迭代器interator

迭代器：一种惰性获取数据项的方式，当访问一个较大的数据集时，按需一次获取一个数据项。
在Python中，可直接作用于for循环的对象都称为可迭代对象，可迭代对象的数据类型有下面两类：
①集合类型数据，str、list、tuple、dict、set等。
②生成器，包含生成器和带yield的生成器函数。
可迭代对象不一定是迭代器，但迭代器一定是可迭代对象。
str、list、tuple、dict、set都是可迭代对象iterable，但不是迭代器iterator，可以通过迭代器中的iter()函数把这些可迭代对象转换成迭代器。
迭代器中有两个基本方法：iter()、next()，使用iter()创建一个迭代器后，就可以通过next()获取迭代器的下一个值，如果通过next()不断调用并返回下一个值，那么等到最后没有下一个值了，就会抛出异常StopIteration。
其实for循环的本质就是不断调用next()，之所以不会抛出异常，是因为使用了try except，当遇到StopIteration就退出循环break

from collections import Iterable, Iterator

print('int是否为可迭代对象', isinstance(222, Iterable))
print("str是否是可迭代对象", isinstance("222", Iterable))
print("str是否是迭代器", isinstance("222", Iterator))
print("str用iter转换后是否是迭代器", isinstance(iter("222"), Iterator))

'''
int是否为可迭代对象 False
str是否是可迭代对象 True
str是否是迭代器 False
str用iter转换后是否是迭代器 True
'''

a = [1,2]
iter_a = iter(a)
print(next(iter_a))
print(next(iter_a))
print(next(iter_a))
'''
1
2
Traceback (most recent call last):
  File "test.py", line 56, in <module>
    print(next(iter_a))
StopIteration
'''

# for...in...相当于下面的函数
a = [1,2]
iter_a = iter(a)
while True:
    try:
        print(next(iter_a))
    except StopIteration:
        break

# 用迭代器实现斐波那契数列Fibonacci sequence
# F(0)=1 F(1)=1 F(n)=F(n-1)+F(n-2) (n>=2 n是正整数)
class Fib:
    def __init__(self, count):
        self.count = count # 迭代次数
        self.last = 0  # 第n-1个值，初始值为0
        self.current = 1 # 第n个值，初始值为1

    def __iter__(self):
        return self

    def __next__(self):
        if self.count > 0:
            value = self.current
            # n+1，把当前值赋给上一个值，把当前值和上一个值相加赋给下一个当前值，注意，赋值是同时进行的，不能分前后
            self.last, self.current = self.current, self.last + self.current
            self.count -= 1 # 迭代次数减一
            return value
        else:
            raise StopIteration


fib = Fib(11) # 迭代器
fib_list = [i for i in fib ]  # 迭代器生成的列表
print(fib_list)

# [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]

3.4.2、生成器gererator

生成器也是用在迭代操作中，是一种特殊的迭代器。
生成器还可以用于协程。
生成器具有和迭代器一样的特性，但在实现方式上不一样，可以通过两种不同的方式创建生成器，生成器表达式和生成器函数。
①生成器表达式，生成器表达式和列表推导式差不多，只需要把中括号改成小括号。
列表推导式返回的是一个列表对象，生成器表达式返回的是一个生成器对象。

a_list = [i for i in range(5)]
print(type(a_list), a_list)
a_generator = (i for i in range(5))
print(type(a_generator), a_generator)
print(next(a_generator), next(a_generator), next(a_generator))

'''
<class 'list'> [0, 1, 2, 3, 4]
<class 'generator'> <generator object <genexpr> at 0x0000028AD0ABFC10>
0 1 2
'''

②生成器函数： 普通函数一般通过return来返回一个值，生成器函数使用yield来返回
生成器函数和普通函数在执行流程上的区别：普通函数执行到return或最后一行语句时返回；生成器函数每次调用next()方法遇到yield语句才返回，如果再次调用next()，就会从上次返回的yield语句位置继续执行。

# 一个简单的生成器函数
def fun_generator(n):
    yield n

test = fun_generator(10)
print(type(test), next(test))  # 如果next溢出，同样会报错StopIteration

'''
<class 'generator'> 10
'''


# 执行next，遇到yield返回，再次执行next，从上次返回的地方开始执行
def test_generator():
    print('aaa')
    yield 1
    print('bbb')
    yield 2
    print('ccc')
    yield 3

t = test_generator()
next(t)  # aaa
next(t)  # bbb
next(t)  # ccc
next(t)  # 报错StopIteration

使用生成器实现斐波那契数列

# 使用生成器实现斐波那契数列
def fib(n):
    last, current = 0, 1
    while n > 0:
        yield current
        last, current = current, last+current
        n-=1
    
f = [i for i in fib(10)]
print(f) # [1, 1, 2, 3, 5, 8, 13, 21, 34, 55]

以上是两种迭代器和生成器计算斐波那契数列的方法，还可以用递归来进行计算，但是需要注意的是，python是有递归深度的， 默认这个深度是1000， 如果超过这个深度， 会报错RecursionError， 而且就耗费时间而言，生成器 < 迭代器 << 递归计算

import time
def fib(num, last, current):
    last, current = current, last + current
    num -= 1
    if num > 0:
        return fib(num, last, current)
    else:
        return current


t1 = time.time()
m = fib(10, 0, 1)
t2 = time.time()
print(t2 - t1)
print(m) # 89

yield from 是一种简化语法的语法糖
语法糖：计算机语言中添加的某种语法，这种语法对语言的功能没有影响，但是更方便程序员调用。通常语法糖能够增加程序的可读性，从而减少代码出错的机会。

# yield from iterator 等价于
for item in iterator:
    yield item

def test():
    for i in range(1000):
        yield i

# 使用yield from简化
def test_1():
    yield from range(1000) # 从迭代对象range(1000)一个个取值

t = test_1()
print(next(t)) # 0
print(next(t)) # 1

3.4.3、生成器gererator的方法：send()、close()

send 方法包含了next方法，向生成器发送一个值之后就恢复运行，返回值就是yield的值

# 下面这个从0递增的迭代器，如果send值为None，递增不变，如果send有值，就从send的数值开始递增
def test():
    n = 0
    while n < 10:
        n += 1
        send = yield n
        if send is not None:
            n = send

t = test()
print(next(t))    # 1
print(next(t))    # 2
print(t.send(5))  # 6
print(next(t))    # 7
print(next(t))    # 8

close，终止迭代器，正常来说，next在遇到StopIteration异常就会停止迭代，而close执行之后会在函数暂停的地方抛出GeneratorExit异常，从而迭代器抛出StopIteration异常。

def test():
    num = 0
    while num < 10:
        num += 1
        yield num
 
g = test()
print(next(g)) # 1
g.close() # 关闭迭代器
print(next(g))  # 迭代器已经关闭，再使用next会抛出StopIteration异常

throw：再生成器暂停的地方抛出一个异常，并且返回下一个yield的返回值

def test():
    num = 0
    while num < 10:
        try:
            num += 1
            yield num
        except ZeroDivisionError:
            print("ZeroDivisionError")
 
g = test()
print(next(g))
print(g.throw(ZeroDivisionError))  # 抛出异常，返回下一个yield的值
print(next(g))

'''
1
ZeroDivisionError
2
3
'''

总结：
1、生成器是迭代器的一种
2、包含yield的函数都是一种生成器（每次执行到yield会停一下，保存当前信息并返回迭代值），（i for i in range(1,11) ），也是一种生成器
3、生成器记录的是算法，在for循环或者next里才会计算具体的值，所以相对列表而言会更节省空间

---

四、数据序列

4.1、字符串

1、字符串特征
字符串用单引号、双引号或三引号修饰 a = 'tom',三引号支持回车换行

2、下标（索引）
下标的作用就是快速找到对应的数据

str = "abcdd"
str[2]

3、切片
截取一部分内容。字符串、列表、元组都支持切片操作

序列[开始位置下标：结束位置下标：步长]

注意：
①不包含结束位置下标对应的数据，正负整数均可，-1代表倒数第一个数据，依次类推。
②步长是选取间隔，正负整数均可，默认步长为1，复数代表倒序选取
③开始、结束、步长都可以不写

4、常用操作方法
①查找
str.find(子串，开始位置下标，结束位置下标) 返回的是字串第一次出现的下标，返回-1代表子串不存在
str.index(子串，15，20)，返回的也是下标
str.count(子串，15，30)，返回的是下标15到30子串的数量，不存在返回0

②修改
str.replace(旧子串，新子串，替换次数) 字符串替换，替换之后返回新的字符串，本来的字符串是不变的，说明字符串是不可变数据类型
str.split(分割字符，num) ,num为分割字符出现的次数
连接字符.join(多字符串组成的序列) 将多个字符串合并成1个字符串

mylist = ["aa","bb","cc"]
new_str = ",".join(mylist)  #用逗号连接

③大小写转换
将字符串第一个字符转换成大写：str.capitalize()
将字符串每个单词的首字母转换成大写：str.title()
将字符串中大写转小写：str.lower()
将字符串中小写转大写：str.upper()

④删除操作
删除字符串左侧空白字符：str.lstrip()
删除字符串右侧空白：str.rstrip()
删除字符串两侧空白：str.strip()

⑤字符串左右对齐修改
字符串左对齐，不足用指定字符填充（默认空格）str.ljust(长度，填充字符)
字符串右对齐，不足用指定字符填充（默认空格）str.rjust(长度，填充字符)
字符串居中，不足用指定字符填充（默认空格）str.center(长度，填充字符)

⑥判断相关，返回true和false
1是否以某个字符串开头，str.startswith(子串，开始位置下标，结束位置下标)
2是否以某个字符串结尾，str.endswith(子串，开始位置下标，结束位置下标)
3字符串至少有一个字符，并且所有字符都是字母，str.isalpha()
4字符串值包含数字，str.isdigit()
5字符串至少有一个字符并且所有字符都是字母或数字，str.isalnum()
6字符串中只包含空白：str.isspace()

---

4.2、列表list

1、列表的格式
列表可以一次性存储多个数据，且可以为不同的数据类型，但是尽量放相同的数据类型

mylist = [数据1，数据2，数据3.......]

2、列表的常用操作

①查找
·下标 mylist[num]
·函数
1返回指定数据所在位置的下标，mylist.index(数据，开始位置下标，结束位置下标)
2指定数据在当前列表中出现的次数，mylist.count（查找的数据）
3返回列表长度，len（mylist）,len()是公用方法

②判断是否存在，返回boolean
1判断指定数据在某个列表序列，指定数据 in mylist
2判断指定数据不在某个列表序列，指定数据 not in mylist

③增加数据
1列表结尾追加数据，如果数据是一个序列,则追加的是整个序列，mylist.append(数据)
2列表结尾追加数据，如果数据是一个序列，则将这个序列的数据逐一添加到列表，mylist.extend(数据)
3指定位置新增数据，mylist.insert(位置下标，数据)

④删除
1del删除，删除列表，del mylist；删除指定数据，del mylist[下标]
2删除指定下标的数据（默认为最后一个），并返回该数据，mylist.pop(下标)
3移除列表中某个数据的第一个匹配项，mylist.remove(数据)
4清空列表，mylist.clear()

⑤修改
1修改指定下标数据，mylist[下标] = “数据”
2逆置，mylist.reve