黑马程序员技术交流社区
标题: 这些天的学习总结（后续有更新） [打印本页]
作者: 成事在人 时间: 2019-10-29 21:18
标题: 这些天的学习总结（后续有更新）
DAY01
2.2数据类型：
2.3格式化输出：
%s字符串输出；%d有符号十进制整数输出；%f浮点数
2.4字符串的功能s和f
2.5转义字符
\n换行
\t制表符，缩进4个空格
Print（‘输出’，end=‘\n’）=print（）默认换行end=“”表示不换行。
DAY02
2.1Input的特点
2.2数据类型的转换
Int（其他类型数）整型
Float（其他类型数）浮点型
str（其他类型数）字符串类型
tuple（其他类型数）元组类型
list（其他类型数）列表类型
eval（str） 转换成原本类型
整型
浮点型
元组
列表
……
……
2.3运算符分类
算术运算符
赋值运算符 ——有运算则先运算再赋值
Num1,num2,str=1,2,qwe
Num1=num2=num3=1
复合赋值运算符 ——有运算则先运算再赋值
+= -+ *= /= //= %= **=
比较运算符 ——返回值是true 和 false
逻辑运算符
补充：and运算符，只要有一个为0则返回0，否则返回最后一个非0数字；
Or运算符，只有所有值为0结果为0，否则结果为第一个非0数字。
Day03
3.1条件语句
If语法——
多重语句：
If条件and/or 条件：
执行语句
Elif 条件：
执行语句
Else：
执行语句
嵌套语句
If 条件1：
执行语句
If 条件2：
执行语句
注意：如果if后的条件执行，后续的elif和else不会执行
三目运算： 条件成立执行的语句if 条件 else 条件不成立执行的语句
注意：random.randint(0,2)函数是闭区间
3.2 循环
让代码高效迅速执行
3.2.1While循环 ——针对数操作
Break终止整个循环
Continue终止当次循环
While可以嵌套使用，打印九九乘法表等
3.2.2For循环 ——针对字符操作
While可以嵌套使用，打印九九乘法表等。不需要计数器累计。
While和for的区别在于操作对象以及While需要计数器累计，for则按顺序执行。
DAY04
4.字符串
4.0字符串
获取字符串：自定义，爬虫，读取文件，input
‘str’
“str”
‘’’str’’’
“””str”””
单引号双引号三引号都表示对字符串的引用，但只有三引号在换行的时候可以输出换行的情况。但单引号就会报错或只能不换行输出。
单引号容易引起str的报错，在‘I’mstudent’的情况下。就是错的。只能加个转义字符,‘I\’mstudent’.或引号类型不同。
两种输出方式：
name=input()
Input都是字符串
Print（‘名字是：%s’%name）
Print（f‘名字是{name}’）
字符串操作
4.1下标和切片 针对序列的操作
下标就是对每个字符从左到右，从零开始编号。取字符语法：序列名[下标]
切片可以截取对象中某一部分数据。语法：序列名[开始位置下标：结束位置下标：步长]
不包含结束位置下标对应的数据，正负整数均可。（]左闭右开。默认下标为1.
注意：从零开始的一般都是左闭右开。range（开始，结束，步长）也是同样。
对于print（str[开始,结束,步长]）一定要清楚的是开始结束决定了方向，而步长只是正序或倒序输出。总之步长的方向必须与开始到结束的方向一致。
4.2查找函数
find
语法：字符串序列.find（‘子串’，开始位置，结束位置）
index（）两者都是查找其中的子串是否在总字符串中，如果在则返回子串开始时的下标，否则报错。
语法：字符串序列.index（‘子串’，开始位置，结束位置）
rfind（）和find功能相同，只是从右开始查找。下标仍然是正序下标。
语法：字符串序列.rfind（‘子串’，开始位置，结束位置）
rindex（）和index功能相同，只是从右开始查找。下标仍然是正序下标。
语法：字符串序列.rindex（‘子串’，开始位置，结束位置）
count（）返回某个子串在字符串中出现的次数。
语法：字符串序列.count（‘子串’，开始位置，结束位置）
4.3字符串修改
（1）replace（）替换
语法：字符串序列str.replace（旧子串，新子串，替换次数）
返回值是字符串。
（2）split（）返回序列
语法：字符串序列str.split(分割字符，num)
num为分割次数，期间会丢失分割字符。返回值为一个列表list[str,str,str…]，是string转list
（3）join（）连接。用一个‘’字符或子串‘’粘结list中的多个字符，形成新的字符串
语法：‘’字符或子串‘’.join（多字符串组成的list序列）
是列表list转字符串string
（4）capitalize（）将string第一个字符转大写
（5）title（）：将string每一个单词首字母转大写
（6）lower（）：大写转小写
（7）upper（）：小写转大写
（8）lstrip左 rstrip有 strip两边删除多余空白字符
（9）ljust 左对齐 rjust右对齐 center中间对齐
语法：字符串.ljust（长度，填充字符）
注意：字符串是不可变类型，需要有新变量接收返回值。
4.4判断
startswith（）判断字符串是否以某个子串开头。
语法：字符串序列.startwith（子串，开始下标，结束下标）
返回值为true或false
endswith（）
语法：字符串序列. endwith（子串，开始下标，结束下标）
isalpha（）是否都由字母组成
isdigit（）是否全数字
isalnum（）是否全数字或字母
isspace（）是否全空白
上述返回值为“是true”“否false”
5.列表
5.1列表基础
一般存储同一类型的数据
格式：list=[‘’数据1‘’，‘’数据2‘’，……] 以逗号分隔
5.1.1下标——下标直接对应的是数据
下标从左往右，从0开始
取值：list[0]
5.1.2查找 ——查找是查的具体的数据，返回的是下标
index（）查找数据，返回下标
list.lindex(数据，开始下标，结束下标)
count（）查找数据出现的次数
len():访问列表长度，数据个数。
针对列表list则统计数据个数，
针对字符串str则统计每一个字符个数。
5.1.3判断是否存在
(1) in
list=[‘qwe’,’asd’,’zxc’]
print(‘asd’ in list) -----返回值为true或false
(2) not in
同上
5.1.4增加数据
append（）尾部增加数据
语法：列表list.append(数据)
append中的数据整体添加到最后
extend（）尾部增加数据
语法：列表list.extend(数据)
会拆开所有的元素，列表中的元素or字符串中的每个字符。
insert（）任意位置增加数据
语法：insert（位置下标，数据）
元素整体添加到指定下标位置。
5.1.5删除数据
del list[3] 清除对应元素或整个列表
list.pop(3) 清除下标对应元素，默认最后一个。有返回值（即被删除的数据）
list.remove(‘asd’) 清除具体内容
list.clear() 清除其全部内容
5.1.6修改
list[1]=’其他数据’
5．1.6排序
number_list.reverse() #逆序（无逻辑顺序）只是与原序列相反
number_list.sort(reverse=False) #默认升序和降序（有逻辑顺序）12345或54321
5.1.7 复制
copy()
可通过切片进行
5.1.8切片
列表切片：
语法：序列名[开始位置下标：结束位置下标：步长]
list[0,3,1]这对字符串同样适用。
不包含结束位置下标对应的数据，正负整数均可。（]左闭右开。默认下标为1.
5.1.9遍历
while
for i in list:
执行语句
5.1.10嵌套
list=[1,2,3,[4,5,6[7,8,9]]] 列表中的元素类型要一致
查找为：list[4][4][1]=7
6.元组tuple
相当于列表不能修改其中的元素。
6.1定义
t1=(10,20,30) 小括号多元素是特征
元组定义：
判断方式就是看去掉括号的特征。小括号皆可去除。
t1=(1,2,3,4)、t1=1,2,3,4多数据，和列表类似，内部元素类型尽量一致。
多数据的话小括号可省略。都是以元组形式存储。
t2=(1,)单数据。必须加逗号。
空元组定义：
c_tuple = ()
c_tuple = tuple()
其中不添加任何东西，包括逗号之类。
6.1.2查找
（1）下标
tuple[1] 除了这个填下标查内容，其他都是填内容查下标
（2）index()返回下标
tuple.index(‘’qwe’’)
（3）count()返回数量
tuple.count(“qwe”)
（4）len()返回长度
len(tuple)
6.1.3修改
元组中可变类型数据可修改，不可变类型数据不能修改。
t2=(1,2,3,[1,2,3])
红色部分不可更改。
DAY05
7．字典dict
字典无下标，只有键和值
7.1应用
数据以键值对形式存储，字典不支持下标。特征{}
7.2字典操作
dict[key] 查找 字典无下表【key】中的是key键。
7.2.1添加字典
dict={'键1':'值','键2':'值','key3':'值'}键是字符串，值看需要的类型dict={}dict1=dict()7.2.1增加数据
字典序列dict[‘键1’]=‘wer’ 改
字典序列dict[‘键4’]=‘123dfs’ 增，都是以键值对的形式进行！
7.2.2删除数据
del dict['age'] 删除整个键值对
dict.pop(‘key’)
dict.clear() 清空字典，留下空字典
7.2.3修改
字典序列[‘键1’]=‘wer’ 改
7.2.4查找
print(dict[‘key’]) -------增删改查都可以使用这个函数。没有报错。
（1） get() 没有不报错
print（dict.get(‘key’,’默认’)） 有返回值，默认值可以自己设定
（2） keys()查找字典中所有的键keys
print(dict.keys())
print(dict) 默认输出键。
（3） values()查找字典中所有的值
print(dict. values())
（4） items()
print(dict. items ())返回键值对，以元组形式存储。
7.2.5遍历
for key in dict.keys(): keys是默认的，可以不写。获取key信息
for value in dict.values():获取valu信息for item in a_dict.items():获取所有信息，并返回到元组中
for key,value in a_dict.items():
print(f'{key}={value}')实现拆包功能。
注意：dict不能直接转换成list，想要完整转换必须以items的方法，每一键值对转换成元组，然后再依次append到空list中。但是list可以直接转换成dict。
8．集合set。
集合无下标
8.1创建
set={1,2,3,4}或set（‘rqw’），空集只能用set()
特征：无序，去重。数据去重复。没有顺序，不支持下标。
8.2操作
8.2.1增加
set.add(数据)，数据类型不可是列表
集合是可变类型，针对集合本身操作。
set.update([ ]),更新。将整个集合更新。
8.2.2删除
set.remove(9)删除不存数据，报错。
s1.discard(123)删除不存在的数据，不报错。
s1.pop()随机删除某数据并返回这个数据。<因为集合无下标>
8.2.3查找
in
not in
返回true和false
9．公共操作
9.1运算符
print(str1+str2)
print(list1+list2)
print(tuple1+tuple2)
都是拼接。
print(str1*5)
print(list1*5)
print(tuple1*5)
都是复制。
print('a'not in str1)
print(12 in list1)
print(2 in tuple1)
print(2in dict1)
返回true和false
9.2公共操作
enumerate（可遍历对象，start=下标起始值） #枚举，返回下标、元素。
返回的是元组，每一个元组为（原迭代数据的下标，原迭代数据）
for i in enumerate(list1):
print(i)
9.3容器类型装换
转换类型（原类型）
列表list（），元组tuple（），集合set（）相互转换
字符串str（），和整型int（）…相互转换
9.4推导式
类似三目运算
9.4.1列表推导式
列表，字典，集合这些可变类型的可以直接使用推导式，其他的间接使用。
用一个表达式创建或控制一个有规律的列表
合并列表为字典
list1=[i for i in range(0,9,1) if i%2==0] =[返回值,代码体]
相当于将for循环简化.
基本格式：
10.函数
先定义，再调用
基本步骤：
搭建整体框架
确定功能界面
封装函数
调用函数
10.1函数的定义
def 函数名（形参）：----定义
代码1
代码2
……
函数名（实参）---------调用
先定义，再使用。
封装代码，代码重用。
函数是一个完成的且独立代码块，如果想要使用外部数据就必须要通过参数传递进去。否则报错。
10.1.1参数
参数的规定
（1）位置参数：形参实参个数顺序必须完全一致。
（2）关键字参数：关键字参数=实参，可以打乱顺序。age=43,gender=male……
但是位置参数的优先级高于关键字参数，必须在其前边，无论形参还是实参，包括不定长参数的关键字传递情况位置参数也不能置后。func(a, b=30, *args, **kwargs)只有这个情况除外。且各自两组之间也不能乱序。（3）缺省参数：形参可以设置“缺省参数”即提前设置默认值，可以被实参修改。key=value
def show(a=0, b=0, c=0, d=0) #提前定义的形参都是省缺参数。
show（1,2，3,4） #这里是实参，修改后的可以传递。
（4）不定长参数：自行组包。接收位置参数+关键字参数：
包裹位置传递：def 函数名（*args） 函数名（‘实参1’，‘实参2’……）返回元组。
包裹关键字传递：def 函数名（**kwargs） 函数名（name=‘实参1’,……）返回字典。
可以传数据也可以不传，返回空元组或字典。位置和关键字是不能混用的。
实现完全的不定长操作,即在实参上自由长度设置.需要用map(func, *iterables)
*的功能就是打包成元组传递**则是打包成字典传递，而完整的*args或**kwargs本身则就是传递的完整的实参本身，和普通参数一样。
a=1→**kwargs →{‘a’=1} 这个过程的反向也是成立的。
补充：拆包。对组包（元组或字典）进行多变量传递。有几个参数做几个变量传递。
元组拆包：a,b = tuple(a1,b2)
字典拆包：a,b = dict{:,:} dict[a] dict #a,b在这里接收的是key。
形参=实参 等号前后能够成立就可以填入。
形参是局部变量，被调用才分配内存。实参是视情况而定。
参数的传递：第一个函数的return值可以作为第二个函数的参数。
10.1.2变量
作用域
局部变量：函数内部（代码1，代码2）定义的变量是局部变量，只能在内部执行。临时保存数据，执行完毕销毁不能传递。
全局变量：函数外部定义的变量是全局变量，函数体内外都能访问。或内部<global变量>
全局变量在函数的外部定义,局部变量在函数的内部定义。形参都视作局部变量。
注意：局部变量不存在直接调用全局，局部变量已经存在，函数内就只关注局部变量。
修改全局变量
函数内部修改全局变量：
global 变量 #声明
变量 = 修改值 #修改
变量如果被global，而不重新赋值，那么还是原有的值。
注意：在函数内部，使用global修饰变量时，在global关键字之前不能使用被修饰变量（函数体内）。否则报错。
交换变量值
（1） c=0
a=1
b=2
c=a
a=b
b=c
实现a和b值的互换
（2） a,b=1,2
a,b=b,a
变量的传递
Python中值都是通过引用传递，无论可变还是不可变类型。
a,b作为变量必须被（数值型，字符，列表，元组，字典，集合等）赋值才能传递临时分配给后者的存储空间及id地址给变量，变量间只能传递这个地址。
实参也可以通过引用传递。
可变类型：在同一个id进行数据修改
不可变类型：在修改并返回数据到新变量后会转到不同id。
10.1.3定义说明文档
定义——
def 函数名（参数）：
“””说明””” #首行多行注释
代码
查看——
help(函数名) 查看函数的说明文档。
10.1.4嵌套
一个函数套另一个函数
def test_B():
print('first line')
print('last line')
def test_A():
print('第一行')
test_B()
print('最后一行')
test_A()10.1.5 return返回值
return 本身功能是结束函数
return 表达式
返回表达式运行结果。
return 1，2 [1,2] {1:1,2:2}
可以返回多个数据，元组，列表，字典，默认返回元组。
只有返回值可以返回并改变参数物理地址，其中的代码体不返回其结果就无法被保存。
注意：函数本身是独立的代码体，分配了独立的空间，而调用语句本身则按顺序进行。
函数必须在调用之前定义才能被调用。
10.2递归
特征：自我调用，要有出口。
业务逻辑重复的情况下使用。
rerun表达式。 只有表达式运算完毕，才能返回结果给函数
无出口报错，最大递归深度990-1000
10.3 lambda表达式 又称匿名函数
相当于推导式，用于简化函数代码
变量=lambda 参数：返回值表达式
特点：一句代码，一个返回值的函数可用lambda表达式。
参数列表可有可无，表达式与参数同样使用；
接收任意数量的参数但必须只返回一个表达式的值。
示例：实现的是同一个功能。
def add([url=]a,b[/url]
[11] ): n个参数
return [url=]a+b[/url]
[12] 1个返回表达式
print(add(1,2))
相当于把函数的def换成了lambda置后括号换成等号，lambda自带拆解list功能。
add=
lambda [url=]a,b[/url]
[13] : [url=]a+b[/url]
[14]
print(add(1,2))
两个结构方式：
1） 定义：函数名 = lambda 形参 ： 返回值表达式
调用：结果 = 函数名(实参)
2）定义并调用：结果 = (lambda 形参 ：返回值表达式)(实参)
由于只有一个返回值表达式，所以结合三目运算或推导式很方便。
所有的模式跟函数类似，只是适用于简单的函数改编：只有一个返回值的那种。
sort(key=,…)
sort自行遍历列表，底层封装。
其中key只能接收函数
10.3.1参数
一个参数
默认参数
可变参数，不定长位置参数*args
可变参数，不定长关键字参数**kwargs
和函数里完全一致。
10.3.2判断句（结合推导式）
10.4高阶函数
把函数作为参数传入，称之为高阶函数。
10.4.1基本构造
求绝对值函数：abs（）
求四舍五入函数：round（）
def sum_num(a,b,f):
return f(a)+f(b)
result=sum_num(12.4,-34,abs)
print(result)
其中abs可以转变成其他的函数形式。由f(可以是任意变量)接收和return后的（）结合形成完整函数。
10.4.2内置高阶函数
这些高阶函数似乎都自带遍历list的功能，包括sort（）函数。
（1）map（func，list）
func是功能函数，list是序列
功能：将func的功能作用到list变量的每一个元素。
例子：列表list中每个元素的平方计算。
list1=[2,34,2,56,6]
def func(x):
return x**3
print(list(map(func,list1)))
list()实现的是数据的转换
类型地址（如迭代器可以进行类型转换）
而类型地址对应的内存地址无法进行类型转换。
（2）reduce（func，list）
func函数需要有两个参数，list是序列
需要调用functools模块
功能：func计算的结果继续和list序列的下一个元素做累积计算。
例子：累加计算。将a,b两个变量依次作用与list每个元素，实现累加。
import functools
list1=[2,34,2,56,6]
def func(a,b):
return a+b
result=functools.reduce(func,list1)
print(result)
（3）filter（func，list）
功能：过滤序列，过滤掉不符合条件的元素，返回一个filter对象。
例子：实现偶数的过滤，即过滤掉非偶数，返回的对象是偶数（的内存地址）。
list1=[2,34,2,7,6]
def func(x):
return x%2==0
result=filter(func,list1)
print(list(result))
10.5文件操作
功能：
方便存储
步骤：
打开文件
读写操作
关闭文件
10.5.1基本操作
（1）打开
f=open(文件名，访问模式)文件名可以包括文件的路径
f=open(‘test.txt’,’r’)模式上主要是‘r’ ’w’ ’a’。
‘r’是只读模式，默认模式。
‘w’‘a’模式下会自动生成文件名文件。
结合f.write（）‘w’模式会覆盖内容，而‘a’模式则继续在后续添加。
（2）读,写……
f.read(num) #num表示读取文件内容的长度。默认读全部。
只有在只读模式下才能读取文件中数据。（注意换行符占用一个字节）
readlines（）按照行的方式读取数据，返回列表，元素为每一行的数据。
readline（）按照行的方式读取数据，但一次读取一行内容。
f.write(‘内容’)只能写入字符串。
只有在‘w’‘a’系列模式下才能书写到文件中数据。
文件的读写模式分为r（读取），w（写入），a（追加）三部分，相应的读写模式只能进行相应的操作。
（3）关闭
f=close()
是必须要加的，否则一直占用内存，不利于大型程序的运行。
注意：r系列，文件不存在则报错。w系列，文件不存在则生成。
二者的文件指针都在开头，从头编写。但a的指针则在结尾，追加内容。
但凡带b的都是针对二进制的操作
但凡带+的都是可读可写
但凡有r则文件不存在报错
但凡有w和a文件不存在生成
带b的模式在输入时用格式：f.write(b’str’)
注意：
‘w+’如果不按照‘w’的模式正常写入，就会被默认为写入空并覆盖整个文件。（指针在开头）
‘a+’如果不按照‘a’的模式正常写入，就会被默认为写入空不覆盖整个文件。（指针在结尾）
注意指针的位置，在完全运行完write（）之后，直接read（）的指针是在最后的。
python中文件操作的基本语法如下：
①格式一（手工关闭格式）：
file = open("文件名", "读写模式")file.close()②格式二（免关闭格式）：
with open("文件名", "读写模式") as file: 相应的操作10.5.2指针操作
seek()
对象.seek(偏移量，起始位置)
起始位置：0：开头；1：当前；2.结尾
seek（）对文件的‘a’或’w’的write的并无影响。
注意：函数除了正常运行之外，是有返回值的，返回值必须被接收。返回后表示函数的结束。这算是两种方法进行函数运算——代码体&返回值。
python做除法运算，默认保存浮点数。
特殊函数及知识点：
1. 一切的括号（除算术运算）都只是形式。可有可无。实现数据的传递只需要形式近似就可以传递，如：j=（a,b,c）,(q,w,e)=j,则（a,b,c）==(q,w,e)。括号还可以去掉。。。简直是扯淡！
2. 切片和range(0,10)是左闭右开，默认整型。
3. random.randint(0,10)0到10随机数字。左闭右闭。
4. 下标可以正数也可以倒数。
5. 下标列表同样从0开始，一般对它的操作都是左闭右开，只能取到前一位。
6. 数值型int,float字符串str和元组tuple是不可变类型，需要有新变量接收返回值。
7. 列表list字典dict集合set数据是可变数据类型，无返回值不需要新变量接收。
原则：可变类型无返回值只需要输出原变量，直接对其本身操作。
不可变类型有返回值需要传递给其他变量或print（），不可对其操作。
8. 字符str串特征加“”；列表list特征加[ ];元组tuple（1,2,3）;字典dict{ }.
9. 类型装换——变量名（原类型）
10. 注意字典dict和集合set无下标。
11. id（）用于查询地址。注意：只要是被传递的函数（无论任何类型）都指向同一id，对可变类型而言，就是牵一发而动全身，传递过程中任何一个环节改动，都是针对最初地址中内容的改动，所有指向这一地址的变量内容都要变。对不可变类型也是同样的道理，地址保持一致，只是后者连最初的改动都不能进行罢了。
但是对于传递内容要注意是否是原变量。若有改动就是赋了新值，或者对形参或变量本身直接重新赋值（都不再指向原地址），都会改变其指向地址。
| 欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) |
黑马程序员IT技术论坛 X3.2 |