(课程学习笔记)Python基础学习

1.python概述和环境

1.1python安装目录的介绍
DLLS:python的动态链接库，跟编译器有关，和python编程关系不大
Doc:python的参考书，有很多实例
Lib:这个库很重要，是python的标准库，你扩充的库都安装在这里
Libs：python的内置库，语法存在的地方
Scripts：项目用到的各种脚本
Tools：python提供的一些工具
Tcl：桌面编程包
Lib和Libs的区别？
Lib是python的标准库，我们安装的第三方模板都在这里面，libs是python的内置库，下载python的时候自带的。所以我们不要把API(应用程序接口)放到libs，要放到lib中。

1.2python的脚本

1.2.1python脚本结构
.py文件
以.py后缀的文件是python源代码文件，由python.exe解释，可在控制台下运行，当然也可以用文本编辑器修改。
.pyc文件
以.pyc后缀的文件是python编译文件，.pyc文件是不能用文本编辑器修改的，其优点是执行速度远快于.py文件。至于为什么要有.pyc文件，这个需求是.py文件可以看到源代码，软件开发商不可能把源代码泄露出去，所以就编译成.pyc文件再发布。

1.2.2python成熟的编译器
Sublime
Pycharm
Ipython
IDLE python gui（python自带的简单的集成开发环境）
我们主要使用Pycharm，带有一整套可以帮助用户在使用python语言开发时提高效率的工具。

1.2.3python脚本运行
安装完成，打开win+r，cmd，输入python

2.python字符串常用操作
2.1字符串确实是一个数组，索引是从0开始的
例:name=‘abcdefg’
print(name[0]) —a
2.2字符串的截取操作
#字符串[start:end]:包头不包尾
例:name=‘abcdefg’
print(name[0:3]) —abc
#步长截取：同样包头不包尾
字符串[start🔚step]：按照step步长进行隔取
例：name=‘abcdefg’
print(name[0:6:2]) —ace
#默认取法
[start🔚step]这三个参数都是有默认值的，start为0，end为字符串结尾元素，step为1。若step>0则表示从左向右进行切片，此时start必须小于end才有结果；若step<0，还是表示从左到右只不过反过来切片，此时start必须大于end才有结果。
例：name=‘abcdefg’
print(name[0:6:2]) —ace
print(name[6:0:-2]) —gec
2.2字符串的查找操作
count：计数功能，返回自定字符串在字符串中的个数
find：从左往右查找第一个指定字符串的索引，没有返回-1
rfind：从右往左查找第一个指定字符串的索引，没有返回-1
index：从左往右查找第一个指定字符串的索引，没有报错
rindex：从右往左查找第一个指定字符串的索引，没有报错
2.3字符串的分割替换操作
partition：把mystr以str分割成三部分，str前，str自身，str后
rpartition：类似于partition函数，只不过从右开始
splitlines：按照行分割，返回一个包含\n作为元素的列表，按照换行符分割、
replace：从左往右替换指定的元素，可以指定替换的个数，默认为全部替换
例：
mystr = ‘hello world’
print(mystr.partition(‘o’)) --(‘hell’, ‘o’, ’ world’)
print(mystr.rpartition(‘o’)) --(‘hello w’, ‘o’, ‘rld’)
print(mystr.replace(‘h’,‘q’)) --qello world
mystr = ‘hello\n world\n pathon\n’
print(mystr.splitlines()) --[‘hello’, ’ world’, ’ pathon’]
2.4字符串的变形
upper：字母转大写
lower：字母转小写
swapcase：大小写互换
title：将字符串中的单词首字母大写，单词以非字母划分
capitalize：只有字符串的首字母大写
expandtabs：把字符串中的tab符号(’\t’)转为空格，tab符号(’\t’)默认的空格数是8，可以试下8，12
2.5字符串的判断
isupper：是否完全是大写
islower：是否完全是小写
isdigit：是否完全是数字
isalpha：是否完全由字母组成
isalnum：是否完全由字母或者数字组成
istitle：字符串是否满足title格式(首字母大写)
isspace：字符串是否完全由空格组成
startswith：判断字符串的开头字符，也可以截取判断
endswith：判断字符串的结尾字符，也可以截取判断
split：通过指定分隔符对字符串进行切片，如果参数 num 有指定值，则分隔 num+1 个子字符串，分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等，分割次数。默认为 -1, 即分隔所有。

3.python列表、元组、字典、集合
3.1列表
*列表的定义
name = [‘12’,12,[1,2,3]]
#列表里面的数据类型是可变的，甚至可以嵌套一个列表
列表是一个有序的，可修改的，元素以逗号隔开，以中括号包围的序列。
*列表和字符串的区别
列表和字符串的索引类似，但列表是可以通过索引修改的，而字符串不可以。
*列表的基本操作
append：列表尾部加入指定元素
insert：将元素加入指定的索引上，注意负索引
extend：将指定序列的元素依次追加到列表的尾部(合并)
pop：返回并删除指定索引位上的元素，默认删除索引位-1的元素
remove：从左往右删除一个指定的元素
del：删除整个列表或列表的数据
count：计数，摸个元素在列表中的个数
index：从左往右查找一个元素，没有找到报错
in：是否在列表中，有返回true，没有返回false
reverse：顺序倒序
sort：按照ascii码进行排序，注意列表中如果有不同类型的数据不能进行比较
*list函数
list()，以一个序列作为参数并把它转换为列表，如果参数是list，那么该参数就会被原样返回
例：
a = ‘abcd’
print(list(a)) —[‘a’,‘b’,‘c’,‘d’]
b = [‘a’,‘b’,‘c’]
*列表的切片操作
列表的切片操作和字符串一样
例：
list1 = [0,1,2,3,4,5,6,7,8]
list1[0:6] --[0,1,2,3,4,5]
list1[0:6:2] --[0,2,4]
list1[::-1] --[8,7,6,5,4,3,2,1,0]
list1[6:0:-1] --[6,5,4,3,2,1]

3.2元组
*元组的定义：元组是有序的(只有在定义的一瞬间可以修改)，不可修改的，以逗号隔开，以小括号包围的序列，可以通过()和tuple函数定义。
例：
tuple1 = (11,22,33,‘a’)
tuple2 = (11,) --tuple
tuple3 = (11) --int
注意：元组在定义时如果只传入一个参数，必须要在后面加一个’，’，不然就是int类型而不是tuple类型
*元组的优点：
1.由于不可变，遍历元组比列表要快
2.由于不可变，相当于数据被保护，所以一些重要数据都写在元组
*修改元组
说明：python中不允许修改元组的数据，包括不能删除其中的数据。
元组是不可变的，元组中的元素被赋值后不能改变。但是，如果元素本身是一个可变数据类型的裂变，那么其嵌套项可以被改变。
例：
num = (1,‘a’,[1,2])
num[0] = 2 --报错，不可修改
num[2].append(3) --可以修改，追加一个3
print(num) --(1,‘a’,[1,2,3])
*tuple函数
tuple函数的功能与list函数基本上一样，以一个序列作为参数并把它转换为元组，如果参数是元组那么该参数就被原样返回。
列表转元组：
list1 = [‘a’,‘b’,‘c’,1,2,3]
num1 = tuple(list1)
元组转列表：
list2 = list(num1)
字符串转元组：
str1 = ‘hello world’
tuple1 = tuple(str1)
print(tuple1) --(‘h’, ‘e’, ‘l’, ‘l’, ‘o’, ’ ', ‘w’, ‘o’, ‘r’, ‘l’, ‘d’)
元组转字符串：
str2 = ‘’.join(tuple1)
print(str2) --hello world
元组转int整数：
a = (1,2,3)
str = ‘’.join([str(i) for i in a])
print(str) --123
print(int(str)) --123
*元组的嵌套
tup1 = ((‘落手’,‘雪人’,‘寒冰’),(‘女枪’,‘猴子’,‘大嘴’))
print(len(tup1)) --2
print(tup1[1]) --(‘女枪’, ‘猴子’, ‘大嘴’)
print(tup1[1][1]) --猴子
*元组的切片
tup1 = (0,1,2,3,4,5,6)
print(tup1[0:6]) --(0, 1, 2, 3, 4, 5)
print(tup1[0:6:2]) --(0, 2, 4)
print(tup1[::-1]) --(6, 5, 4, 3, 2, 1, 0)
print(tup1[6:0:-1]) --(6, 5, 4, 3, 2, 1)
*元组的操作
index：从左往右查找第一个指定字符串的索引，没有报错
count：返回元组中指定元素的个数

3.3 字典
*字典的定义
字典是一个无序的，可以修改的， 元素呈键值对的形式，以逗号分开，以大括号包围的数据类型。
查询
info = {‘name’:‘lili’,‘addr’:‘beijing’,‘age’:18}
print(info[‘name’]) --lili
print(info.get(‘name’)) --lili
添加和修改
info = {‘name’:‘lili’,‘addr’:‘beijing’,‘age’:18}
info[‘like’]=‘basketball’
print(info) --{‘name’:‘lili’,‘addr’:‘beijing’,‘age’:18,‘like’:‘basketball’}
info[‘age’]=22
print(info) --{‘name’:‘lili’,‘addr’:‘beijing’,‘age’:22,‘like’:‘basketball’}
删除
del info[‘like’]
print(info) --{‘name’:‘lili’,‘addr’:‘beijing’,‘age’:22}
*字典的特性
1.字典是无序的，所以字典没有索引值
2.字典没有索引值，所以字典以键取值
3.字典以键取值，所以字典的键唯一且不可修改
4.字典的键不可修改，所以列表和字典等可变类型的数据不可以给字典做键
*字典的常见操作
keys：返回一个包含字典所有key的列表
values：返回一个包含字典所有value的列表
get：以键取值，如果指定键不存在，默认返回None，可以指定返回内容
setdefault：设置默认，如果键存在，返回值，如果键不存在创造键，值默认为None，值亦可以自定义setdefault(key，default=None)
update：以字典格式更新指定键的内容，如果键不存在，创建键和值
items：返回字典键值呈元组形式的格式
len：键值对的个数
pop:返回并删除指定键对应的值
popitem：随机弹出一个键值元组，这里随机的原因是因为字典本身无序
in：判断指定的键是否在字典中
info = {‘name’:‘lili’,‘addr’:‘beijing’,‘age’:18}
print(‘name’ in info) --True
for…in…：通过for…in…的语法结构，我们可以遍历字符串、列表、元组、字典等数据结构
info = {‘name’:‘lili’,‘addr’:‘beijing’,‘age’:18}
#遍历键
for i in info:
print(i)
#遍历值
for i in info.values():
print(i)

3.4 集合
*集合定义
集合是一组无序不重复的元素集合。
集合和之前的列表、元组类似，可以存储多个数据，但是这些数据是不重复的。
可以使用{}或者set()函数创建集合，注意：创建一个空集合必须用set()而不是{}，因为{}是用来创建一个空字典。
set1 = {1,2,3,4}
set2 = set()
print(type(set1)) --<class ‘set’>
print(type(set2)) --<class ‘set’>
*集合的交集、差集、并集、对称差集
交集(&)：两个集合的公共部分
并集(|)：两者集合合并，没有重复元素
差集(-)：只有前者有的元素，不存在后者中的元素
对称差集(^)：只在a或b中，但是不会同时出现在二者中
a = set(‘1234’)
b = set(‘3456’)
print(a&b) --{‘4’, ‘3’}
print(a|b) --{‘5’, ‘6’, ‘4’, ‘3’, ‘1’, ‘2’}
print(a-b) --{‘2’, ‘1’}
print(b-a) --{‘5’, ‘6’}
print(a^b) --{‘5’, ‘6’, ‘1’, ‘2’}
*set、list、tuple之间的转换
a = ‘hello’
b = list(a) --[‘h’, ‘e’, ‘l’, ‘l’, ‘o’]
c = tuple(a) --(‘h’, ‘e’, ‘l’, ‘l’, ‘o’)
d = set(a) --{‘l’, ‘h’, ‘e’, ‘o’}
*集合的操作
add：无规律的添加元素
update：也可以添加元素，且参数可以是不同类型，并用逗号隔开
remove：删除集合中指定的元素，当指定的元素不存在时会报错
discard：删除集合中指定的元素，当指定的元素不存在时不会报错
pop：随机删除集合中的一个元素

4.python运算和流程控制循环
4.1python运算
4.1.1布尔值(bool)
True：非0的数字，非空的(字符串、列表、元组、字典)
False：0，’’，()，[],{}，None
4.1.2自增运算
其他语言的自增 i++ 等同于 i=i+1
python语言的自增 i+=1 等同于i=i+1
4.1.3 not,and,or
执行顺序为：not>and>or

4.2python流程控制
流程控制三兄弟：if，for，while
4.2.1 if语句
if 条件1 :
block语句块
else if 条件2 :
block语句块
else :
block语句块

4.2.2 for语句
for 变量 in 可迭代对象 :
block语句块
*特殊的for循环(序列解包赋值)：
list中的tuple遍历
a = [(1,2),(3,4),(5,6)]
for i,j in a :
print(“这是i %s” %i)
print(“这是j %s” %j)
嵌套循环(重要)
外层循环1次，每层循环1遍
for 条件1 :
条件1满足时，做的事情1
for 条件2 :
条件2满足时，做的事情2
例：九九乘法表
for i in range(1,10) :
for j in range(1,i+1) :
print(’%d x %d = %d\t’ %(j,i,ji),end=’’)
print()

4.2.3 while语句
当满足while条件时，就一直循环while，直到不满足条件
while(条件) :
条件满足时，做的事情
else :
条件不满足时，做的事情

4.2.4 流程控制词
pass:写在任何缩进的语句块部分，只是占位，什么事情都不做，等着以后再来补全代码
continue:提前结束本轮循环，开始下一轮循环
break:直接退出循环

4.3 推导式
4.3.1 列表推导式
列表推导能非常简洁的构造一个新列表：只用一条简洁的表达式即可对得到的元素进行转换便变形
语法：[变量 for 变量 in 可迭代对象]
例1：比如我们现在要生成一个列表，列表当中的元素为0-10。
首先我们不用列表推导式。
result = []
for i in range(11) :
result.append(i)
print(result) --[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
用推导式。
result1 = [i for i in range(11)] --[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
例2：一组列表l1=[[1,2,3],[4,5,6],[7,8,9]],如何取出1/4/7和1/5/9呢？
l1 = [[1,2,3],[4,5,6],[7,8,9]]
result = [i[0] for i in l1]
print(result) --[1, 4, 7]
l1 = [[1,2,3],[4,5,6],[7,8,9]]
result = [l1[i][i] for i in range(len(l1))] --[1, 5, 9]
print(result)
*嵌套for推导式
a = [(i,j) for i in range(1,5) for j in range(6,10)]
print(a) --[(1, 6), (1, 7), (1, 8), (1, 9), (2, 6), (2, 7), (2, 8), (2, 9), (3, 6), (3, 7), (3, 8), (3, 9), (4, 6), (4, 7), (4, 8), (4, 9)]

4.3.2 字典推导式
语法：
dic = {k:v for k,v in {‘name’:‘jack’,‘age’:18,‘hobby’:‘basketball’}.items()}
print(dic) --{‘name’: ‘jack’, ‘age’: 18, ‘hobby’: ‘basketball’}
4.3.3 集合推导式
语法：
l = [1,2,3,4,4,5,6,2,3]
set1 = {i for i in l}
print(set1)

4.3.3 元组生成式
格式：
a = (i for i in range(5))
for i in a :
print(i)

4.4 深浅拷贝
深拷贝：拷贝所有对象，包括顶级对象以及嵌套对象，所以原始对象的改变不会造成深拷贝里任何子元素的改变
浅拷贝：只拷贝顶级对象，没有拷贝嵌套对象，所以原始数据改变，嵌套对象会改变！
例：
import copy
a = [1,2,3,4,[5,6,7]]
#在这个列表里顶级对象是1，2，3，4，[5，6，7] ,嵌套对象是[5，6，7]里的5，6，7
b = a
c = copy.copy(a) #浅拷贝
d = copy.deepcopy(a) #深拷贝
print(“a的id是%s,b的id是%s” %(id(a),id(b))) --a的id是2678960247688,b的id是2678960247688
print(“c的id是%s,d的id是%s” %(id©,id(d))) --c的id是2679009389896,d的id是2678960789576
a.append(9) #添加了一个顶级对象9
a[4].append(8) #嵌套对象[5，6，7]添加了一个8
print(a) --[1, 2, 3, 4, [5, 6, 7, 8], 9]
print(b) --[1, 2, 3, 4, [5, 6, 7, 8], 9]
print( c) --[1, 2, 3, 4, [5, 6, 7, 8]]
print(d) --[1, 2, 3, 4, [5, 6, 7]]

5 函数装饰器
5.1 递归函数
函数的内部调用了自身本身，这个函数就是递归函数，递归会形成一个深度循环。
5.2 函数的划分
按照参数类型划分：位置参数、关键字参数、默认参数、参数组
位置参数：是我们在传参时，实参传递的顺序按照形参定义的顺序进行传递的传参方式。
def func(name,city) :
print(“我的名字叫%s，来自%s” %(name,city))
func(‘tracy’,‘houston’) --我的名字叫tracy，来自houston
关键字参数：传参的时候，以形参等于实参的形式忽略形参定义的顺序进行传参的传参方式。
def func(name,city) :
print(“我的名字叫%s，来自%s” %(name,city))
func(name = ‘tracy’,city = ‘houston’) --我的名字叫tracy，来自houston
func(city = ‘houston’,name = ‘tracy’) --我的名字叫tracy，来自houston
默认参数、缺省参数：定义参数的时候我们给形参一个默认值，在我调用函数的时候，如果不给有默认值的形参传参，会自动采用默认值。
注意：默认参数，必须要在普通参数的最后面
def func(name,city = ‘beijing’) :
print(“我的名字叫%s，来自%s” %(name,city))
func(‘zhaosi’) --我的名字叫zhaosi，来自beijing
func(‘zhasi’,‘liaoning’)–我的名字叫zhasi，来自liaoning
参数组：处理比当初声明时更多的参数，会将传入的参数变成元组(args)或者字典(kwargs)，声明的时候不用命名。
1.元组参数组
通过给形参前面添加使参数变成一个元组，所有传递的参数变成元组的元素
def say_hello(*args) :
print(args)
say_hello() --()
say_hello(1,2,3,4,5) --(1, 2, 3, 4, 5)
2.字典参数组
通过给形参前面添加使参数变成一个字典，所有传递的参数变成字典的键值对，这里传递参数要求键等于值的形式。
def say_hello(**args) :
print(args)
say_hello() --{}
say_hello(a=1) --{‘a’: 1}
say_hello(a=1,b=2,c=3) --{‘a’: 1, ‘b’: 2, ‘c’: 3}

5.3 匿名函数lambda
不存在函数名的函数
语法：lambda 参数:表达式(block)
参数：可选，通常以逗号分隔的变量表达式形式，也就是位置参数
表达式：不能包含循环、return、elif，可以包含if，else
例：
l = lambda x : xx
print(l(5))
def l(x) : --此匿名函数的展开式
return xx
l = lambda x : ‘x大于5’ if x>5 else ‘x小于等于5’
print(l(5))
5.3.1 map()
map()是python的内置函数，它接受一个函数和一个可迭代的对象，并且通过函数依次作用在可迭代对象的每个元素上，得到一个新的对象。
a = [1,2,3]
b = [4,5,6]
c = map(lambda x,y:x+y,a,b)
print(list©) – [5, 7, 9]

5.4 作用域
name = ‘while’#作用于全局，全局变量
def outer():
name = ‘for’#嵌套作用域
def inner():
name = ‘dj’#本地作用域
age = 18
print(name)
print(age)
inner()

outer() --dj 18

6 函数装饰器
6.1 闭包的定义：
1.闭包函数必须有内嵌函数；
2.内嵌函数可以引用该嵌套函数上一级namespace(命名空间)中的变量；
3.闭包函数必须返回内嵌函数；
注意：通过这三点就可以创建一个闭包，python装饰器就是使用了闭包
例1:
def outer():
print(“我是outer函数”)
def inner():
print(“我是inner函数”)
return inner

f = outer() #inner
print(f) --<function outer…inner at 0x00000289CC27E0D8>
outer()() #等于inner()

例2：
def outer(num) :
def inner(num_inner) :
return num_inner+num
return inner

a = outer(20) #a==inner a()==inner()
print(a(200)) --220

6.2 装饰器
装饰器是程序开发中经常会用到的一个功能，用来在原有的函数上增添新的代码需求。
执行顺序：先返回内嵌函数->有参数直接传参给内嵌函数->执行内嵌函数
例：
def func1():
print(‘this is func1’)

def outer(func):
def inner():
func()
print(‘i come from china’)
return inner

f1 = outer(func1)
f1()
#this is func1
i come from china
但是上面的操作我们在给一个函数进行装饰的时候会调用f1这个函数，但是我们调用func1的时候并没有给我装饰上具体的需求，python认为上面的写法不简洁，所以提出了@语法糖
def outer(func):
def inner():
func()
print(‘i come from china’)
return inner

@outer #func1=outer(func1) 此时func1这个变量就相当于inner
def func1():
print(‘this is func1’)

func1() #此时func1()就相当于inner()
–this is func1
i come from china
例：模拟登录验证
import time
a = [‘susisi’,‘xulutao’,‘suyiang’]

def outer(func) :
def inner(name) :
func(name)
print(‘开始判断你有没有登录’)
time.sleep(2)

if name in a :
    print('您已经登录，可以进行访问')
    time.sleep(1)
else :
    print('你没有登录，没有权限进行访问')
    time.sleep(1)

return inner
1
2
3
4
5
6
7
@outer #func1=outer(func1) 此时func1这个变量就相当于inner
def login(name):
print(’%s要浏览’% name)
@outer
def goods_car(name):
print(’%s要加入购物车’% name)

login(‘susisi’)