python 基础（笔记）

1. 环境安装

• 需要安装 python 解析器（解析器是吧 python 语言，解析成计算机可以认识的01代码）、代码编辑器（方法编写 python 代码）
• 解析器下载 exe 直接双击安装即可
• 编辑器需要去官网下载 PyCharm 面向专业开发者的 Python IDE

2. 第一个程序 hello word

# 以下代码会打印一个 hello word
print("hello word")

3. 注释

# 我是单行注释

"""
  我是多行注释
"""

4. 变量

4.1 变量声明

# 此时 num 就是一个变量，变量可以被修改也可以做运算等
num = 123

4.2 命名规则

1. 内容限定，限定只能使用：中文、英文、数字、下划线，注意：不能以数字开头
2. 区分大小写
3. 不可使用关键字，True、False、None、and、as、if、import、yield… 等

4.3 命名规范

1. 见名知意
2. 下划线命名法
3. 一个单词字母全小写

5. 运算符

5.1 算术运算符

运算符	描述	示例
+	加	10 + 10 = 20
-	减	10 - 5 = 5
*	乘	10 * 10 = 100
/	除	10 / 10 = 1
//	取整除	9 // 2 = 4
%	去余	9 % 2 = 1
**	指数	2 ** 3 = 8

5.2 赋值运算符

运算符	描述	解释
=	赋值运算符	直接赋值
+=、-=、*=、/=、%=、**=、//=	复合赋值运算符	先本身和后面的数值进行计算，在赋值给自己

num += 3 # num = num + 3

5.3 比较运算符

运算符	描述	实例
==	比较左右两边是否相等，返回布尔值	3 == 3 为 True
!=	比较左右两边是否不相等，返回布尔值	3 != 3 为 False
>	比较左边是否大于右边，返回布尔值	5 > 3 为 True
<	比较左边是否小于右边，返回布尔值	5 < 3 为 False
>=	比较左边是否大于等于右边，返回布尔值	4 >= 4 为 True
<=	比较左边是否小于等于右边，返回布尔值	5 <= 4 为 False

6. 数据类型

6.1 数据类型

type(xxx)：可以用于查看数据类型

列：

• type(123) ==> <class 'int'>
• type(123.123) ==> <class 'float'>
• type(True) ==> <class 'bool'>

类型	描述	说明
数字（Number）	支持： 整数（int）、浮点数（float）、复数（complex）、布尔（bool）	整数：10、-10，浮点数：13.14、-13.14，复数：4+3j，以 j 结尾表示复数，布尔：既真和假，True 表示为真记作1，False 表示假记作0
字符串（String）	描述文本的一种数据类型	字符串由任意数量的字符组成
列表（List）	有序的可变序列	Python 中使用最频繁的数据类型，可有序记录一堆数据
元组（Tuple）	有序的不可变序列	可有序的记录一堆不可变的 Python 数据集合
集合（Set）	无序不重复集合	可无序的记录一堆不重复的 Python 数据集合
字典（Dictionary）	无序的 Key-Value 集合	可无序记录一堆 Key-Value 型的 Python 数据集合

6.2 数据类型的转换

• int(x)：将 x 转换为 int 类型，x 有限制，当 x 为字符时，字符内容只能为纯数字，不然会报错
• float(x)：将 x 转换为 float 类型，x 有限制
• str(x)：将 x 转换为 str 类型，x 没有限制

7. 字符串操作

7.1 字符串定义的几种方式

• 单引号定义

  'hello word'
  

• 双引号定义

  "hello word"
  

• 三引号定义

  # 三引号的方式，如果不用变量接收那么就是多行注释，如果用变量接收就是多行字符串，*三引号定义建议使用双引号
  s = """
  	hello word
  	hello word
  """
  

• 引号之间的嵌套

  # \ 为转义字符，把特殊字符当做字符使用
  "'hello word'"
  '"hello word"'
  "\"hello word\""
  '\'hello word\''
  

7.2 字符串拼接

# 字符串拼接都是使用 + 号，可以字符串与字符串拼接，也可以和变量拼接
h = "hello"
w = "word"

h + w
h + "word"
"hello" + "word"

7.3 字符串格式化

• %s 插入字符，“hello %s” % “word”
• %：表示占位
• s：表示插入的位置

# 如果为多个 %s，后面则需要一个小括号一一对应
print("大家好我叫%s，今年%s岁了" % ("张三", 18))

格式符号	转化
%s	将内容转换成字符串，放入占位位置
%d	将内容转换成整数，放入占位位置
%f	将内容转换成浮点数，放入占位位置

• f"内容{变量}"：第二种插入方式，字符串前面加上一个 f 可以直接使用变量

7.4 字符串精度控制

• 以下代码将内容转换成浮点数会出现精度丢失的问题

  print("大家好我叫%s，今年%f岁了" % ("张三", 18))
  # 大家好我叫张三，今年18.000000岁了
  

• 需要对数字做精度控制，我们可以使用辅助符号 “m.n” 来控制数据的宽度和精度
  • m：控制数字整数部分的长度，设置的长度小于数字的长度，不生效，大于则空格补齐
  • n：控制数字小数部分精度，设置的长度小于小数的长度，四舍五入，大于则零补齐`
  • 例："%7.2f" % 15.146 ==> [空格][空格]15.15（一共有七个字符长度）

8. 数据输入

• input(“提示内容”)
• input() 会中断程序的执行，等到键盘按下回车，才会执行后续的代码
• input() 输入的内容始终为字符串

  name = input("请输入你的名字")
  
  print(f"你的名字是：{name}")
  

9. 语句

9.1 if 判断语句

• if

  """
    语法（根据 tab 来判断是否属于当前 if 语句，规范为 4 个空格）
  
  if 判断条件:
      满足条件执行结果
      满足条件执行结果
  
  不受 if 的约束
  """
  
  # 代码示例，只有最后一个 print 才会打印
  age = 16
  
  if age > 18:
      print("我已经成年了")
      print("我长大了")
  
  print("我不知道我多少岁")
  

• else

  """
  语法
  
  if 判断条件:
      满足条件执行结果
  else:
      不满足条件执行结果
  """
  

• if elif else

  """
  语法
  
  注意一个语句中只会执行一个条件，如果多个条件同时满足，执行最先匹配的
  if 判断条件:
      满足条件执行结果
  elif 判断条件:
      满足条件执行结果
  ...elif
  else:
      不满足条件执行结果
  """
  

• if 嵌套

  # 嵌套也是根据 tab 来判断的
  if True:
      print("第一层if开始")
      if True:
          print("第二层if")
  
      print("第一层if结束")
  
  print("最外层if")
  

9.2 循环语句1

9.2.1 while 循环

# 如果条件一直满足就会一直执行，嵌套和 if 用法一样，这里就不一一叙述了
while 条件:
    满足条件执行结果

9.2.2 for 循环

"""
# 嵌套和 while 用法一样
待处理的数据集(序列类型)，字符串、列表、元组...

for 临时变量 in 待处理的数据集:
"""
name = "abcd"

for k in name:
	print(k)

# a
# b
# c
# d

9.3 循环语句2

9.3.1 range 语句

• 作用：获得一个数字序列
• 语法：
  • range(num)：获取一个从 0 ~ num - 1 的数字序列
  • range(num1, num2)：获取一个从 num1 ~ num2 - 1 的数字序列
  • range(num1, num2, step)：步长不在是 1 了，比如 (5, 10, 2) ==> 5、7、9

for i in range(5)
	print(i)

# 0
# 1
# 2
# 3
# 4

9.3.2 for 循环临时变量作用域

# 这种情况外层的 print 语句是可以访问到变量 i 的，但是规范上不建议这么做
for i in range(3):
    print(i)

print("我是外层的i", i)

# 0
# 1
# 2
# 我是外层的i 2


# 最好是在外层在定义一个 i
i = 0
for i in range(3):
    print(i)

print("我是外层的i", i)

9.3.3 continue 与 break

• continue 与 break 都是对当前层的影响
• continue 跳过当前循环

  for i in range(3):
      print("我是前面的", i)
      continue
      print("我是后面的", i)
  
  # 我是前面的 0
  # 我是前面的 1
  # 我是前面的 2
  

• break 结束循环语句

  for i in range(3):
       print("我是前面的", i)
       break
       print("我是后面的", i)
  
  # 我是前面的 0
  

10. 函数

10.1 函数的作用

• 将功能封装在函数内，可供随时随地的重复利用
• 提高代码的复用性，减少重复代码，提高开发效率

10.2 函数的定义

• 函数调用时传入的实参与形参对应
• 函数 return 的值，调用时可以接收到，如果不写 return 默认返回 None
• 在当前作用域中如果 return 后面还有代码，则 return 后面的代码不会执行
• 函数要先定义才能使用

def 函数名称(形参1, 形参2):
	# 函数体 code

	# 函数返回
    return ""

# 函数调用
函数名称(实参1, 实参2)

10.3 函数的描述

# 键盘敲三个 "，然后回车，编辑器直接会出当前参数和返回值的架子，需要自行添加详细描述
def add(a, b):
    """
    两数相加
    :param a: 参数1
    :param b: 参数2
    :return: 返回两个数的和
    """
	return a + b

10.4 函数的嵌套

# 代码从上向下依次执行
def a():
    print("我第二个执行")

def b():
    print("我第一个执行")
    a()
    print("我第三个执行")

b()

# 我第一个执行
# 我第二个执行
# 我第三个执行

10.5 全局变量与局部变量

# 函数中定义的变量外部无法访问
def a():
    num = 100
a()
print(num) # name 'num' is not defined


# 函数中无法修改全局的变量（但是可以拿到），下面这段代码函数 a 中的 num 相当于又在局部声明了一个
num = 50
def a():
    num = 100
a()
print(num) # 50


# global 关键字，设置内部的变量为全局变量
num = 50
def a():
    global num
    num = 100
a()
print(num) # 100

10.6 函数案例，ATM 机

"""
	初始账户有 5000
	重复一下操作直到退出，1：查看余额，2：存款，3：取款，4：退出
"""

money = 5000
name = input("请输入您的名称")
flag = True

def view():
    """
    查看余额
    :return:
    """
    print(f"{name}的余额为{money}")


def save():
    """
    存款
    :return:
    """
    num = int(input("请输入存款金额"))
    global money
    money += num


def take():
    """
    取款
    :return:
    """
    num = int(input("请输入取款金额"))
    global money
    if num > money:
        print("取款失败，账号没有这么多余额")
    else:
        money -= num


def main():
    """
    主程序
    :return:
    """
    i = int(input("请输入您的操作，1：查看余额，2：存款，3：取款，4：退出"))
    if i == 1:
        view()
    elif i == 2:
        save()
    elif i == 3:
        take()
    else:
        global flag
        flag = False

while flag:
    main()

11. 数据容器

11.1 列表

11.1.1 列表的定义

# 字面量
[元素1, 元素2, 元素3, 元素4, ...]

# 定义变量
变量名称 = [元素1, 元素2, 元素3, 元素4, ...]

# 定义空列表
变量名称 = []
变量名称 = list()

11.1.2 列表的基本操作

# 定义一个普通列表
arr1 = ["元素1", "元素2", "元素3", "元素4"]

# 定义一个嵌套列表
arr2 = ["元素1", ["元素2_1", "元素2_2"], "元素3"]

# 通过列表下标获取列表中的数据
# 从左向右 0、1、2、... ，从右向左 -1、-2、-3、...
print(arr1[0]) # 元素1
print(arr1[-1]) # 元素4

# 或者嵌套列表中的数据
print(arr2[1][0]) # 元素2_1

# 获取超出范围的内容，会报错
print(arr[4]) # IndexError: list index out of range

# 修改列表中某个元素的值
arr1[0] = "我是修改的值"

# 删除列表中某个元素的值
del arr1[0]

# 获取列表的长度
len(arr)

11.1.3 列表的方法

# 注，列表统一使用 arr
arr = [1, 2, 3]

方法名称	作用	示例	返回值	原列表
index	查找指定元素的下标	arr.index(1)	列表索引，0	[1, 2, 3]
count	统计传入元素的数量	arr.count(2)	统计数量，1	[1, 2, 3]
insert	在指定位置插入元素	arr.insert(1, 666)	None	[1, 666, 2, 3]
append	在列表尾部添加单个元素	arr.append(666)	None	[1, 2, 3, 666]
extend	在列表尾部添加多个元素	arr.extend([666, 777])	None	[1, 2, 3, 666, 777]
pop	删除指定位置的元素	arr.pop(0)	删除的元素	[2, 3]
remove	从左向右搜索并删除第一个指定元素	arr.remove(1)	None	[2, 3]
clear	清空列表	arr.clear()	None	[]

11.1.4 列表的遍历

arr = [21, 25, 21, 23]

# while 循环遍历
i = 0
while i < len(arr):
    print(arr[i])
    i += 1
# 21
# 25
# 21
# 23


# for 循环遍历
for i in arr:
    print(i)
# 结果与 while 循环一致

"""
	区别：
		while 更灵活
		for 更简单
"""

11.2 元组

11.2.1 元组的定义

# 元组可以理解为是只读的列表
# 字面量
(元素1, 元素2, 元素3, 元素4, ...)

# 定义变量
变量名称 = (元素1, 元素2, 元素3, 元素4, ...)

# 定义空元组
变量名称 = ()
变量名称 = tuple()

11.2.2 元组的基本操作

# 定义单个元素的元组，后面一定要加一个逗号
t1 = (元素1, )

# 元组的嵌套
t2 = ((元素1_1, 元素1_2, 元素1_3), (元素2_1, 元素2_2, 元素2_3))

# 通过下标获取元素
print(t2[0][0]) # 元素1_1

# 获取元组的长度
print(len(t2)) # 2

# 修改元组中的值会报错
t2[0][0] = "改变的值" # 'tuple' object does not support item assignment

# 但是元组中嵌套列表是可以修改的
t = (1, 2, [1, 2])
t[2][0] = 2
t[2][1] = 4

11.2.3 元组的方法

# 注，元组统一使用 t
t = (1, 2, 3)

方法名称	作用	示例	返回值
index	查找指定元素的下标	t.index(1)	列表索引，0
count	统计传入元素的数量	t.count(2)	统计数量，1

11.2.4 元组的遍历

t = (2, 4, 6)

# while 循环
i = 0
while i < len(t):
    print(t[i])
    i += 1

# for 循环
for i in t:
    print(i)

11.3 字符串

11.3.1 字符串的基本操作

# 字符串也可以像列表一样通过下标去获取，字符串也是一个只读属性
s = "hello word"

print(s[0]) # h
print(s[-1]) # d

# 返回字符串的长度
print(len(s)) # 10

11.3.2 字符串的方法

# 注，字符串统一使用 s
s = "hello word"

方法名称	作用	示例	返回值
index	查找指定元素的下标	s.index(“ll”)	列表索引，2
replace	将字符串进行替换	s.replace(“ll”, “hh”)	新的字符串，“hehho word”
split	将字符串按指定形式进行分割	s.split(" ")	列表，[“hello”, “word”]
strip	将字符串首尾的字符按指定形式清除	“12121266666212121”.strip(“12”)， 传入的参数是单个识别的，是存在1、2 都清除，而不是12， 如果不传参数默认清除的是首尾的空格	新的字符串，“66666”
count	统计字符串出现的次数	s.count(“l”)	次数，2

11.3.3 字符串的遍历

# 字符串的遍历和列表、元组的遍历是一样的，这里就不演示了

11.4 序列的切片

11.4.1 序列的定义

• 内容连续、有序、可使用下标索引的一类数据容器
• 列表、元组、字符串都可以视为序列

11.4.2 序列的操作

• 语法：序列[起始下标:结束下标:步长]
• 起始下标
  • 表示从何处开始（包含开始位置），可以为空，为空表示从头开始
• 结束下标
  • 表示从何处结束（不含结束位置），可以为空，为空表示一直到最后
• 步长
  • 步长不写默认为 1，为 1 表示一个个的取元素
  • 为 2 表示，每次跳过 1 个元素取
  • …
  • 为负数表示反相取，起始下标和结束下标也要反向标记

arr = [1, 2, 3, 4, 5, 6, 7]

print(arr[0:3]) # 包含 0，不包含 3，[1, 2, 3]

print(arr[::]) # 全部使用默认值，[1, 2, 3, 4, 5, 6, 7] 

print(arr[::-1]) # 相当于倒序，[7, 6, 5, 4, 3, 2, 1]

print(arr[::2]) # 隔一个取，[1, 3, 5, 7]

print(arr[4:2:-1]) # 倒着截取，[5, 4]

11.5 集合

11.5.1 集合的定义

# 定义集合
s1 = {元素1, 元素2, 元素3, 元素4, ...}

# 定义空集合
s2 = {}
s3 = set()

# 获取集合的长度
len(s1)

11.5.2 集合的方法

#  注，集合统一使用 s1、s2
s1 = {1, 2, 3}
s2 = {4, 5, 6}

方法名称	作用	示例	返回值	原集合
index	查找指定元素的下标	arr.index(1)	列表索引，0	[1, 2, 3]
count	统计传入元素的数量	arr.count(2)	统计数量，1	[1, 2, 3]
insert	在指定位置插入元素	arr.insert(1, 666)	None	[1, 666, 2, 3]
append	在列表尾部添加单个元素	arr.append(666)	None	[1, 2, 3, 666]
extend	在列表尾部添加多个元素	arr.extend([666, 777])	None	[1, 2, 3, 666, 777]
pop	删除指定位置的元素	arr.pop(0)	删除的元素	[2, 3]
remove	从左向右搜索并删除第一个指定元素	arr.remove(1)	None	[2, 3]
clear	清空	arr.clear()	None	[]

更新中…