Python学习

为了争强好胜，开始学AI

1.安装Python解释器

• 前往python官网(https://www.python.org/)
• 下载python
  

2.字面量

• 字面量就是直接写到代码中的具体值
• Python的字符串中可以包含任意字符，且必须使用引号包起来
• 字符串的引号，可以是：单引号、双引号、三个单引号、三个双引号
• 写在Python文件头部的字符串，会被自动识别成docstring（文档字符串），文档字符串的主要作用是对当前Python文件进行一些说明，且文档字符串必须用三个双引号

3.变量

3.1变量的定义

变量名 = 值

• 在python中，当一个新的变量出现时，必须立即与某个值建立绑定关系

4.标识符的命名规则

• 只能包含数字、字母、下划线，不能以数字开头，不能包含空格
• 标识符区分大小写
• 不能使用关键字，常用的关键字如下
  
• 标识符尽量不能与内置函数同名
• 常用的变量写法如下，python推荐使用蛇形
  

5.常量

• 常量就是一旦被赋值，就不希望被修改的值
• Python中的常量使用全大写标识，并且设计多个单词时，用下划线进行分割
• Python中没有强制的常量机制，常量本质还是变量

6.注释

• 单行注释：#后一段内容

#单行注释

• 多行注释：python中没有像java一样的多行注释，使用三个单引号/双引号的方式编码，所以多行注释本质上是一个字符串

'''多行注释'''

• 文件编码注释，指定当前文件的字符编码，Python3默认采用UTF-8作为编码，UTF-8被称为万国码，可以对任意语言进行编码

#coding=utf-8

7.数据类型

7.1整数

• 整数就是没有小数点的数字，可以是正数、负数、0
• 当数字很大时，可以使用下划线将数字进行分组

salary = 300_000
house_price = 3_200_000
graduates = 12_000_000

• Python中整数的上限值，取决于执行代码的计算机的内存和处理能力

7.2浮点型

• 浮点型就是带有小数点的数字。

weight = 65.2
balance = 1425.58
out_temp = -25.2
price = 120.0

• 浮点型的科学计数法表示。

speed_of_sound = 3.4e+2 #3.4乘以10的2次方。
world_population = 7.8e9 #7.8乘以10的9次方。
distance_sun_earth = 1.496E8 # 1.496乘以108次方.
speed_of_light = 2.998E+8#2.998乘以10的8次方。

7.3字符串

7.3.1字符串的定义

• 单引号和双引号的写法是等价的，二者都不能直接换行(要用圆括号才能换行)单引号用的多

message1='尚硅谷，让天下没有难学的技术!'
message2="尚硅谷，让天下没有难学的技术!"

• 三个单引号的写法，可以直接换行，并且可以作为多行注释使用。

message3='''尚硅谷，让天下没有难学的技术!'''

• 三个双引号的写法，可以直接换行，也可以作为多行注释使用，还能作为文档字符串使用。

message4="""尚硅谷，让天下没有难学的技术!"""

7.3.2字符串的格式化输出

7.3.2.1直接用加号进行拼接

只能进行字符串之间的拼接

info1 = '我是'+gender+'生'

7.3.2.2使用占位符

%s占位字符串，%f占位浮点数，%i占位整数，%d占位十进制的整数，%s是万能的。如果类型和占位符不一致，py解释器将会进行转换，如果占位符定义的是%d，实际为浮点型，则会将浮点型数据的小数部分进行丢弃。

info2='我叫%s，我是%s生，我体重是%d,年龄是%d'%(name,gender,weight，age)

7.3.2.3使用f-string

本质上就是将变量都转换为字符串，也是最常用的方式

info3=f'我叫{name}，我是{gender}生，我体重是{weight}，年龄是{age}'

7.3.2.4浮点型精度控制

7.4布尔类型（bool）

布尔类型是int类型的子类型，底层的本质使用1表示True，用0表示False，这一点让我想到了C++中的宏定义，有的宏的确是这样定义的。
True：真

False：假

7.5NoneType

None是一个特殊的字面量，表示空值/无值/无意义，类型转换为false

7.5数据类型转换

# 将指定类型转换为字符串
result1 = str(1)
result2 = str(2.01)
print(f'result1 = {result1},result2 = {result2}')

# 将指定类型转换为整形,自动去除前后空格,整数去除小数部分
result3 = int('  1  ')
result4 = int(2.51)
print(f'result3 = {result3},result4 = {result4}')

#将指定类型转换为浮点型,自动去除前后空格
result5 = float(' 1.01 ')
result6 = float(2)
print(f'result5 = {result5},result6 = {result6}')

#将指定类型转换为布尔型,0为假,非0为真
result7 = bool(0)
result8 = bool('11111111111')
print(f'result7 = {result7},result8 = {result8}')

运行结果如下：

E:\Code\python\python_basic\.venv\Scripts\python.exe E:\Code\python\python_basic\test1.py 
result1 = 1,result2 = 2.01
result3 = 1,result4 = 2
result5 = 1.01,result6 = 2.0
result7 = False,result8 = True

Process finished with exit code 0

8.算数运算符

9.比较运算符

字符串的比较：首先比较两个字符串每个字符的unicode值，如果相等则依次往下比较，如果前几个字符都相等，则比较长度。

10.逻辑运算符

# and具有短路的能力
# and返回的不一定是布尔值，它返回的是某个参与计算的值本身
# and会先看左边，如果左边是假，就会直接返回左边，否则会返回右边
# 如果参与and运算的值不是布尔值，那Python会自动转为布尔值，然后再进行逻辑操作
print(2 - 2 and True)
print('' and True)
print(True and 8 / 2)
print(3 + 3 and 3 * 4)

# or也具有短路的能力，返回的是参与计算的值本身
# 若参与or运算的值不是布尔值，python会自动转换为布尔值，然后进行逻辑判断，如果左边为真，就返回左边，否则返回右边
print(7 - 2 or False)
print(False or 1 - 0)

11.进制

# 10进制
a = 10
print(a)
# 8进制
b = 0o10
print(b)
# 16进制
c = 0x10
print(c)

12.input用户输入

# 使用input获取用户输入的内容，这些内容都是字符串类型的
age = input('请输入你的年纪:')
print(f'你的年龄是{age}，类型是{type(age)}')

13.流程控制语句

13.1单分支

age = 18
if age >= 18:
    print('你是一个成年人')
    print('成年人的事情虽然很痛苦，但是很精彩')
print('继续行走吧')

13.2双分支

13.3多分支

13.4while循环

13.5for循环

13.5continue和break

只能作用于当前循环

• continue：跳过本次循环
• break：立即结束循环

14.函数

函数是组织好的，可重复的，用于执行特定任务的代码块，常用函数分类如下：

14.1函数的定义

函数要先定义，再使用

14.2参数的使用

python的实参和形参的数量必须一致，这一点和java是一致的

def add(a, b):
    return a + b

print(add(1, 2))

如上图所示，调用函数时，根据参数在函数中出现的顺序，把实参的值依次传递给形参，这叫做位置参数

def add(a, b, c):
    return a + b + c

print(add(1, c=2, b=1))

如上面代码所示，调用函数时，指定实参传递的形参，这种叫做关键字参数，需要注意的是关键字参数要在位置函数后面

但是需要注意的是/前面只能用位置参数，*后面只能用关键字参数

def add(a, b, c=2):
    return a + b + c


print(add(1, c=2, b=1))

如上图所示，可以设置参数默认值，如果c没有传递值，将默认c为2，如果有值，将进行覆盖，需要注意的是形参设置了默认值，就要放在最后面。

# *args被称为可变参数，是将参数封装为一个元组，**kwargs被称为关键字参数，是将参数封装为一个字典。
# 需要注意的是，*args要放在**kwargs后面
def add(a, *args, b, **kwargs):
    print(a, args, b, kwargs)

print(add(1, 2, 3, 4, b=1, c=2))

14.3函数的返回值

函数执行完毕后，会将执行结果交给调用者，这个执行结果被称为返回值，python使用return关键字作为函数的返回值，return会结束函数执行，并将return后的值，作为函数的返回值。

14.4作用域

• 全局变量：在当前文件的任意位置
• 局部变量：只能在当前的函数中使用，函数结束之后，变量被释放

14.4.1gloabl关键字

将当前变量声明为全局变量

14.5递归调用

递归调用就是函数自己调用自己的操作

14.6函数的说明文档

pytyon的函数命令文档是写到函数体的第一行中，在pycharm中输入三个双引号并且回车就可以生成参数文档。

def add(a, *args, b, **kwargs):
    """
    打印正常参数、位置参数、关键字参数
    :param a: 正常参数
    :param args: 位置参数
    :param b: 正常参数
    :param kwargs: 关联字参数
    :return:
    """
    print(a, args, b, kwargs)

print(add(1, 2, 3, 4, b=1, c=2))

15.数据容器

一种能存放多个数据的数据类型，类似于java中的集合

15.1列表

15.1.1定义列表

# list类型的定义
list1 = [1, 2]
list2 = ['1', '1231']
list3 = [1, 2.1, '我试试', True, None]

# 空列表
list4 = []
list5 = list()

# 嵌套列表
list6 = [1, [2, 3]]

15.1.2下标

列表中元素的位置编号

15.1.3CRUD

15.1.3.1新增

# 定义一个列表
list1 = [1,2,3,4,5]
foreach_list(list1)
# 使用append添加到尾部
list1.append(6)
foreach_list(list1)
# 使用insert向指定下标插入
list1.insert(0, 0)
foreach_list(list1)
# 使用expand扩展添加可迭代对象
list1.extend([7,8,9])
foreach_list(list1)

15.1.3.2删除

# 定义一个列表
list1 = [1, 2, 3, 4, 5, 1]
# 使用pop方法删除指定下标的元素，并返回
result = list1.pop(1)
# 使用del关键字删除指定下标的元素，不返回
del list1[2]
# 使用remove方法删除列表中第一次出现的值
list1.remove(1)
# 使用clear方法删除所有的元素
list1.clear()

15.1.3.3修改

# 定义一个列表
list1 = [1, 2]
# 修改指定下标的元素
list1[1] = 3

15.1.3.4查询

# 定义一个列表
list1 = [1, 2]
#遍历
print(list1)

15.1.4常用方法

以下方法只适用于常规列表，嵌套列表不适用

15.1.5循环遍历

# 定义一个列表
list1 = [1,2,3,4,5,6,7,8,9,10]
# while循环
index = 0
while index < len(list1):
    print(list1[index])
    index += 1

# for循环
# 写法一，常用
for i in list1:
    print(i)
# 写法二，range函数
for i in range(len(list1)):
    print(list1[i])
# 写法三，enumerate函数,7是用来指定索引的起始值，但是没有修改真正索引值
for index,item in enumerate(list1, 7):
    print(index,item)

15.2元组(tuple)

元组是一种和列表类似的数据容器，他和列表的区别是：元组中的元素是不可修改的，但是如果元组中存放了可变类型，可变类型中的内容仍可修改。

# 定义一个元组
tuple1 = (1, 3)
# 定义一个空的元组
tuple2 = ()
tuple3 = tuple()
# 定义一个只有一个元素的元组,需要添加一个,
tuple4 = (1,)

15.2.1常用方法

15.2.2内置函数

15.3函数解包列表或传参

15.4字符串

字符串就是存放多个字符的容器

15.4.1常用方法

15.4.2常用的内置函数

15.5序列的切片

• 什么是序列？

能连续存放元素的数据容器，元素有先后顺序，且可以通过下标访问，例如：列表、元组、字符串

• 什么是切片？

从序列中按照指定范围，取出一部分元素，形成一个新的序列的操作。

15.5.1语法说明

序列[起始索引:结束索引:步长]

• 起始索引默认从零开始，下标为0
• 结束索引默认为元素的个数
• 步长默认为1

# 定义一个列表
list1 = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
# 常用的切片
list2 = list1[0:5:1]
print(list2)
# 使用默认值的切片
list3 = list1[::]
print(list3)
# 步长为负数的切片
list4 = list1[::-1]
print(list4)
# 结束索引超出序列范围
list5 = list1[:1000:]
print(list5)

打印结果如下：

E:\Code\python\python_basic\.venv\Scripts\python.exe E:\Code\python\python_basic\test1.py 
[10, 20, 30, 40, 50]
[10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
[100, 90, 80, 70, 60, 50, 40, 30, 20, 10]
[10, 20, 30, 40, 50, 60, 70, 80, 90, 100]

15.6序列的相加

15.7集合（set/frozenset）

集合分为可变集合和不可变集合，可变集合是指创建后可以增删元素，不可变集合是指创建后不可以增删元素。集合的特点就是内部的元素无序，并且不能通过下标访问元素，会自动去除元素。

# 定义一个集合
set1 = {1, 3, 4}
print(set1, type(set1))
# 定义一个空集合
set2 = set()
print(set2, type(set2))
# 不能使用{}，因为{}创建的是一个字典、
set3 = {}
print(set3, type(set3))
# frozenset不可变集合，接受的参数可以是任意可迭代对象，但是返回的一定是不可变集合
set4 = frozenset({1, 2, 3})
print(set4, type(set4))

集合中不能嵌套可变集合，但可以嵌套不可变集合

15.7.1增删改查