python学习记录1

开始之前
python解释器
一般情况下，使用系统自带的解释器即可，也可使用功能更为全面的Anaconda
下载Anaconda
**

第一部分

**
1.字面量
代码中，被写在代码中固定的值，称为字面量。
常见的字面量类型：
整数、浮点数、字符串。
如何基于print语句完成各类字面量的输出？
print(10)#输出整数
print(13.14)#输出浮点数
print(“pytjon”)#输出字符串

2.注释

注释的作用：注释是代码中的解释性语句，用来对代码内容进行注解。注释不是代码，不会被程序执行。
单行注释和多行注释
单行注释：使用 # 进行注释，井号后的内容会被解释器忽略。
多行注释：使用3个" “将要注释的内容填入，可以进行多行书写。（”““要注释的内容””"）

3.变量
变量就是在系统运行时，记录数据用的，变量的值可以改变。变量的定义格式： 变量名=变量值

4.数据类型

类型	说明
string	(字符串）类型，用引号引起来
int	整形）类型，数字类型，存放数字。
float	(浮点数）类型，数字类型，存放浮点数

使用type()函数可以查看数据类型

a=1
b=1.2
c="str"
print(type(a),type(b),type(c))

5.数据类型转换
python中的输入语句：input()
注意：input（）输入的内容，系统默认为字符串。

a=input()
print(type(a))

语句（函数）	说明
int(x)	将x转换为整型
flort(x)	将x转换为浮点数类型
str(x)	将x转换为字符串类型

任何类型都可以转换为字符串类型。
浮点数类型转换为整型时会丢失精度。

6.标识符
在python程序中，我们可以给很多东西取名字，比如：
变量的名字、方法的名字、类的名字，等等。
这些名字，我们把他们统一的称之为标识符，用来做内容的标识。

标识符的命名中，只允许出现中文、英文、数字和下划线_。
标识符的命名中，程序对大小写是敏感的。
标识符的命名中，不可使用关键字。

7.运算符

运算符	描述
+	加
-	减
*	乘
/	除
%	取余
**	指数
//	取整除（返回商的整数部分）

赋值运算符
“=” 等号右边的结果赋值给等号左边的变量。
复合赋值运算符

复合赋值运算符	描述
+=	加法赋值运算符
-=	减法赋值运算符
*=	乘法赋值运算符
/=	除法赋值运算符
%=	取模赋值运算符（a%=c等效于 a=a%c
**=	幂赋值运算符
//=	取整除赋值运算符

第二部分

1.字符串

字符串的定义
（1）单引号定义法：可以内含双引号

a='"python"'

（2）双引号定义法：可以内含单引号

b="'python'"

字符串的叠加
如果有两个字符串变量，我们可以通过+号来将其拼接为一个字符串。

a="python"
b="真好学"
print(a+b)
print("python"+"真好学")

注意：+号无法完成与字符串非字符串的拼接。

字符串的格式化
%s：
%表示：我要占位
s表示：将变量变成字符串放入占位的地方

num=100
print("我今天挣了%s元"%(num))

多个变量占位，变量要用括号括起来并按照占位顺序填入，变量之间应用逗号隔开
。

num=100
num1=10
print("我今天挣了%s元,捡了%s元"%(num，num1))

占位符还有%d,%f 在此不多赘述。

占位符的第二种形式：f" {变量}"
这种方式，不用理会类型，不做精度控制，适合快速使用。

字符串的索引、切片与逆序
"Hello , world!"这个字符串中有13个字符(字符串的计数包含空格和符号)
注意：索引从0开始

H  e  l  l  o  ,     w  o  r  l  d   !
0  1  2  3  4  5  6  7  8  9 10  11  12

H的索引就是0，!的索引就是12
首先，我们需要定义一个变量a使它=“Hello , world!”
获取单个字符w时可以使用变量名[索引]

>>>a = "Hello , world!"
>>>print(a[7])
w

如果此时我们只想获得world这个字符串，那么可以使用切片
切片时我们可以使用变量名[起始索引:结束索引+1:间隔个数]
起始索引默认为0，结束索引默认为最后，间隔个数默认为1，若为默认时可以省略
注意：间隔个数为负时，系统会逆序输出

a="abcdefg"
print(a[::-1])

输出结果为"gfedcba"
python中还有判断字符或字符串存在的in和不存在的not in语句
输出值为布尔值

字符串的方法
字符串.upper() 将字符串里的字符全部大写
字符串.lower() 将字符串里的字符全部小写
字符串.isupper() 字符串中字符是否都是由大写字母组成
字符串.islower() 字符串中字符是否都是由小写字母组成
字符串.isdigit() 字符串中是否都是由数字组成
字符串.isnumeric() 字符串中字符是否都是由数字字符组成
字符串.isalpha() 字符串中是否都是由字母组成，并且非空
字符串.isalnum() 字符串中是否都是由字母和数字组成，并且非空
字符串.isdecimal() 字符串中是否都是由数字字符组成，并且非空
字符串.isspace() 字符串中是否都是由空格、制表符和换行符组成，并且非空
字符串.istitle() 字符串中是否以大写字母开头、后面都是小写字母的单词、数字或空格
字符串.find(字符,起始位置,结束位置) ​ 查找指定字符在字符串中的位置（索引）(找不到则返回-1)
字符串.index(字符,起始位置,结束位置) 查找指定字符在字符串中的位置（索引）(找不到会报错)
字符串.count(字符) 统计指定字符出现的次数
字符串.replace(字符,新字符,替换次数) 用于字符串的修改
字符串.split(分隔符，分割次数) 拆分字符串。通过指定分隔符对字符串进行切片，并返回分割后的字符串列表。
分隔符.join(序列) 返回一个用分隔符连接序列各个元素后的字符串（注：分隔符可以为空）
字符串.title() 字符串内的所有单词的首字母大写
字符串.capittalize() 字符串第一个字母大写
字符串1.startswith(字符串2) 字符串2是否以字符串开始
字符串1.endswith(字符串2) 字符串2是否以字符串结束
字符串.partition(字符串中片段) 以字符串中片段为分隔符分隔字符串
字符串.rjust(数字,‘填充字符’) 右对齐字符串，左边填充上‘填充字符’，总字符长度为‘数字’
字符串.ljust(数字,‘填充字符’) 左对齐字符串，右边填充上‘填充字符’，总字符长度为‘数字’
字符串.center(数字,‘填充字符’) 字符串居中，两边填充上‘填充字符’，总字符长度为‘数字’
字符串.strip(空格、制表符、换行符和字符串参数) 删除字符串两边所选字符
字符串.rstrip(空格、制表符、换行符和字符串参数) 删除字符串右边所选字符
字符串.lstrip(空格、制表符、换行符和字符串参数) 删除字符串左边所选字符

判断语句
1.if 判断条件 :
语句……
2.if 判断条件：
语句……
else：
语句……
3.if 判断条件：
语句……
elif 判断条件：
语句……
n个……
else：
语句……
注意：判断语句下一行应比较上一行后退4个字节

循环语句
循环语句主要分为while语句和for语句

while 语句
while语句由三部分组成：
1.while
2.条件表达式和冒号
3.当条件表达式结果为真时要执行的循环体

while 表达式 ：
循环体

for循环
for 循环变量 in 遍历对象(序列)：
循环体

for 循环，从形式上可以分为俩种：
1.遍历对象
2.使用range函数控制循环次数
range函数:
range(起始值，终止值，步长)
步长 ：每次循环序列增长值
注意：无论是判断语句还是循环语句条件语句都要缩进4个字符。

i = 0#用while循环分别输出0-100的奇数和偶数
while i <= 100:
    if i % 2 == 0:
        print(f"偶数：{i}")
    if i % 2 == 1:
        print(f"奇数：{i}")
    i += 1

for i in range(0,101):#用for循环输出0-100的奇数和偶数
	if i % 2 == 0:
        print(f"偶数：{i}")
    if i % 2 == 1:
        print(f"奇数：{i}")

列表
创建一个空列表：

a = [ ]

访问列表中的某个元素，可以使用

a[索引]

如果要访问列表的最后一个元素，可以使用

a[-1]

看到这里是不是发觉与字符串的索引很像，的确他们的形式是一样的。
以此类推，列表的切片和逆序与字符串格式一致，也是a[ : : ]和a[ : :-1],同时别忘记逆序时开始索引与结束索引的位置。

列表方法
增
列表.append(元素) : 在列表末尾添加一个元素

列表.extend(序列): 在列表末尾追加一个序列（也可为单个元素）
列表.insert(索引，元素): 在列表对应的索引插入元素

a=[1,2,3,4,5,6]
print(a.append(10))
print(a.extend(1,2,3)
print(a.insert(10,1))

删
del 列表[索引]：删除列表中对应索引的元素。
列表.pop(索引): 删除列表中对应索引的元素，并返回删除的元素，默认最后一个。
列表.remove(元素): 删除列表中对应元素的第一个匹配项。
列表.clear():清空列表

改
列表[索引]=新元素：将列表对应索引的元素，修改为新元素。

查
列表.index(元素): 返回元素对应的索引

排序
1.sort()：可以对列表进行永久排序（原列表不变）
列表.sort(reverse=True/False)
2. sorted()可以对列表进行临时排序（产生一个新的列表）
sorted(列表名,reverse=True/False)

reverse=True 时，按降序排序。
reverse=False 时，按升序排序。
一般默认reverse=False，reverse也可不写。

元组
创建一个空元组：

a =（）

创建包含一个元素的元组：

b =（元素,）

创建元组：c =（元素1,元素2,……）

元组的访问
获取一个元素：
元组序列[所有]

获取多个连接的元素：
元组序列[开始索引,结束索引]
注意：元组无法被修改

方法	说明
元组.index()	从元组中找出某个对象第一个匹配项的下标位置
count()	查找元组中某一元素的数量
len()	计算元组长度，并返回值
max()	得到元组中最大的数值
min()	得到元组中最小的数值

字典
创建空字典：

dict1 = {}
dict2 = dict()

创建字典：

dict3 = { 键1 :值1 ,键2: 值2,……}
如：dict3 = {‘name’: ‘小编’, ‘age’: 18}

特点
1.符号为大括号{}
2.数据为键值对形式出现
3.各个键值对之间用逗号隔开

字典的操作
访问值：

字典序列[键]

修改值:

字典序列[键]=新值

添加键值对:

字典序列[新键]=新值

删
删除字典中对应的键的键值对：

del 字典序列[键]

删除字典：

del 字典序列

清空字典：

字典序列.clear()

查
查找字典的所有的键值对：

字典序列.items()

查找字典的所有的key(键)：

字典序列.keys()

查找字典的所有的value(值)：

字典序列.values()

使用enumerate()函数枚举键值对
enumerate(序列, start=0)
其中start = 0为默认开始值为0

in 和not in 操作符
字典中的 in 和not in 操作符与列表和字符串中类似

get()方法
get()方法有两个参数，分别为要取得其值的键，以及当该键不存在时返回的备用值。

>>>a = {'apple':2,'banana':3}
>>>print('I have '+str(a.get('orange',0))+' oranges.')
I have 0 oranges.
>>>print('I have '+str(a.get('apple',0))+' apples.')
I have 2 apples.

集合
可以使用大括号 { } 或者 set() 函数创建集合，但创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

集合特点：
1.集合是一个无序的不重复元素序列
2.集合中的元素是唯一的
3.集合可以用来去重

集合操作
增
添加一个数据：
集合序列.add(数据)

添加序列：
集合序列.update(序列数据)

删
集合序列.remove(数据)
删除集合中指定的数据，如果数据不存在就报错

集合序列.pop()
随机删除集合中的某个数据

集合序列.discard(数据)
删除集合中指定的数据，如果数据不存在不做任何操作

函数
如果在开发程序时，需要某块代码多次，为了提高编写的效率以及代码的重用，就把具有独立功能的代码块组织为一个小模块，这一个小模块就是函数。

作用:
1.减少代码的重复性。
2.使代码可读性更好。

定义函数语法：
def 函数名 ( ):
[][]函数语句
调用函数语法：
函数名( )
注意：1.函数先定义后调用，如果先调用会报错。
2.函数没有被调用时，函数里面的执行语句不会被执行。

返回值
函数并非总是直接显示输出，有时也可以处理一些数据，再返回处理好的数据。函数返回的数据称为返回值。
语法：
def 函数名 ( ):
[][]函数语句
[][]return 返回值
注意：函数中可以同时包含多个 return 语句，但只会执行了一个return,return的功能是返回值并退出当前函数，return语句后面的语句都不执行。

形参和实参
定义格式:

def 函数名(形参1,形参2):
[][]函数体

调用格式:

函数名(实参1,实参2)
注意：1.传递的实参与形参个数必须保持一致，否则将发生参数不匹配错误。
2.编写函数时可给每个形参指定默认值，调用函数时给形参提供实参的，将使用指定的实参，若没有则使用默认值。
3.调用函数时，会将实参1传递给形参1，实参2传递给形参2，……如果参数位置不对，可能达不到预期效果，如果参数过多时可以在调用函数时直接指明形参1=实参1

参数
参数分为三种：
1.位置参数(必备参数)
2.默认参数(缺省参数)
3. 不定长参数(*args,**kwargs)
*args常以元组的形式输出，收集任意数量的位置实参
**kwargs常以字典的形式输出，收集任意数量的关键字实参

位置参数
def 函数名(形参1,形参2):
[][]函数体

函数名(实参1，实参2)

默认参数
def 函数名(形参1=数据,…):
[][]函数体

不定长参数
不定长参数(*args)
def 函数名(*args):
[][]函数体

函数名(实参1，实参2，实参3,……)

不定长参数(**kwargs)
def 函数名(**kwargs):
[][]函数体

参数定义顺序：
位置参数、默认参数、不定长参数(*args,**kwargs)

作用域
变量作用域就是指变量的作用范围，在什么范围内起作用。
变量作用域主要分为局部作用域和全局作用域。

局部作用域
定义在函数内部的变量拥有一个局部作用域，表示只能在声明它的函数内部访问。在函数体内部，临时保存数据，即当函数调用完成后，则销毁局部变量。

全局作用域
定义在函数外部的变量拥有全局作用域，表示可以在整个程序范围内访问（函数内、外部都能生效）

注意：global能将部分变量变为全局变量

>>>def great():
>>>    global a  
>>>    a = 40
>>>    print(f'函数内：{a}')
>>>a = 20
>>>great()
>>>print(f'函数外：{a}')
函数内：40
函数外：40