python基础（B站黑马程序员）

Python字面量

1.字符串

Python中，字符串需要用双引号包围起来，换句话说，被双引号包围起来，都是字符串。

2.注释

注释的分类：

• 单行注释：以 # 开头， # 右边的所有文字当做注释（注意，#号和注释内容一般建议以一个空格隔开）。
• 多行注释：以 一对三个双引号 引起来（“““注释内容”””）。

3.变量

变量有类型吗？
我们通过type(变量)可以输出类型，这是查看变量的类型还是数据的类型？
其实我们查看的是“变量储存的数据的类型。因为，变量无类型，但是他存储的数据有。”

例如：
盒子里面装着足球，便叫足球盒子；
盒子里面装着篮球，便叫篮球盒子。
盒子(变量)没有类型，但是他里面的数据有类型。

4.标识符

在Python程序中，我们可以给很多东西起名字，比如：

• 变量的名字
• 方法的名字
• 类的名字，等等
  这些名字， 我们统一把他们称为标识符，用来做内容的标识。
  所以，标识符：是用户在编程的时候所使用的一系列名字，用于给变量、类、方法等命名。

标识符命名三大规则
规则1：内容限定，限定只能使用：中文、英文、数字、下划线 _ (不能以数字开头)
规则2：大小写敏感
规则3：不可使用关键字

标识符命名规范
(规范是建议性要求，并不是强制性的，但是一般都需要遵守)

变量名的命名规范：

1. 见名知意
2. 下划线命名法
3. 英文字母全小写

5.运算符

算数运算符
（加减乘除）

运算法	描述	实例
//	取整除	返回商的整数部分 9 // 2 输出结果4，9.0 // 2.0 输出结果4.0
%	取余	返回除法的余数部分 9 % 2 输出结果1
**	指数	2 ** 3 为2的3次方，输出结果为8

赋值运算符
（=）

复合赋值运算符
+=
-=
*=
/= (4 /= 2: 2.0 结果为浮点型)
%=
**=
//=

6.字符串

字符串的引号嵌套

如果我要定义的字符串本身，是包含：单引号、双引号自身呢？
1.单引号内 包含双引号
2.双引号内 包含单引号
3.使用转移字符（\）来将引号解除效用，变成普通字符串

字符串的拼接

如果我们有两个字符串字面量， 可以将其拼接成一个字符串，通过+号即可完成

不过一般，单纯的2个字符串字面量进行拼接显得很呆，一般会使用字面量或变量和变量之间会使用拼接，如：

name = "考研408“
print("我最头疼的科目是：" + name + "，但是我一定会学好")

输出：
我最头疼的科目是：考研408，但是我一定会学好

注意：除字符串外的变量无法进行字符串的拼接(如整数，浮点数类型的变量等)。

字符串格式化

通过占位的形式拼接字符串，进行字符串格式化
快速拼接：

name = "八小时"
message = "每天学习%s" % name
print(message)

输出：
每天学习八小时

其中，%s

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

class_num = 57
avg_salary = 16781
message = "Python大数据学科，北京%s期，毕业平均工资：%s" % (class_num, avg_salary)
print(message)

输出：
Python大数据学科，北京57期，毕业平均工资：16781

在Python中，支持非常多的数据类型占位

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

例如：

name = '股民'
set_up_year = 2006
stock_price = 19.99
message = "我是：%s,今天是：%d年，今天的股价是：%f" %(name, set_up_year, stock_price)
print(message)

输出：
我是：股民,今天是：2006年，今天的股价是：19.990000

字符串格式的精度控制

可以使用辅助符号"m .n"来控制数据的宽度和精度

• m ，控制宽度，要求是数字（很少使用），设置的宽度小于数字自身， 不生效
• .n， 控制小数点精度，要求是数字，会进行小数的四舍五入

示例

• %5d：表示将整数的宽度控制在5位，如数字11，会显示：[空格][空格][空格]11，用三个空格补足宽度。
• %5.2f：表示将宽度控制在5，将小数点精度设置为2。而小数点和小数点部分也算入宽度计算。如，对11.345设置了%7.2f后，结果是：[空格][空格][空格]11.35，两个空格补足宽度，小数部分限制2位精度后，四舍五入为.35
• %.2f：表示不限制宽度，只设置小数点精度为2，如11.345设置%.2f后，结果是11.35

字符串格式化 - 快速写法

通过语法：f“内容{变量}”的格式来快速格式化

# 字符串格式化 快速写法
name = '股民'
set_up_year = 2006
stock_price = 19.99
print(f"我是：{
     name},今天是：{
     set_up_year}年，今天的股价是：{
     stock_price}")

输出：
我是：股民,今天是：2006年，今天的股价是：19.99

1.可以通过
f"{变量}{变量}"的方式进行快速格式化

2.这种方式:

• 不会做类型
• 不做精度控制

适合对精度没有要求的时候快速使用

表达式的格式化

表达式：一条具有明确执行结果的代码语句

如何格式化表达式？

• f"{表达式}"
• “%s%d%f” %(表达式，表达式，表达式)

# 表达式的格式化
print("1 * 1的结果是：%d" % (1 * 1))
print(f"1 * 1的结果是：{
     1 * 1}")
print("字符串在Python中的类型是：%s" % type('字符串'))

输出：
1 * 1的结果是：1
1 * 1的结果是：1
字符串在Python中的类型是：<class 'str'>

在无需使用变量进行数据存储的时候，可以直接格式化表达式，简化代码

6.数据输入

• 数据输出：print
• 数据输入：input

使用input()语句从键盘获取输入
使用一个变量接收(存储)input语句获取的键盘输入数据即可
input()输入的数据都会被当做字符串来看待，即数据类型为字符串，如果需要使用数字类型则需要进行数据类型转换。

7.布尔类型

Python中常用的6种数据类型中，数字(Number)类型中有布尔(bool)类型
布尔(bool)表达现实生活中的逻辑，即真和假 其字面量为：

• Ture表示真
• False表示假

True本质上是一个数字1，False记作0。 (所以属于数字类型)

定义变量为布尔类型的数据

变量名称 = 布尔类型字面量
布尔类型的数据，不仅可以通过定义得到，也可以通过比较运算符进行内容比较得到。

#比较运算符
result = 10 > 5
print(f"10 > 5 的结果是 {
     result}, 类型是{
     type(result)}")

输出为：
10 > 5 的结果是 True, 类型是<class 'bool'>

str1 = input('请输入字符串1:')
str2 = input('请输入字符串2:')
result1 = str1 == str2
print(f"字符串1是否和字符串2相等，结果是：{
     result1},类型是{
     type(result1)}")

输出为：
请输入字符串1:aim
请输入字符串2:aim
字符串1是否和字符串2相等，结果是：True,类型是<class 'bool'>

比较运算符

运算符	描述
==	相等
!=	不相等
>	大于
<	小于
>=	大于等于
<=	小于等于
满足为Ture，不满足为False。

8.if语句

if判断语句

if 要判断的条件：（注意一定要带冒号）
条件成立时，要做的事情

if语句注意点

• 判断语句的结果，必须是布尔类型
• 归属于if语句的代码块，需要在前方填充四个空格缩进
• 符合判断条件时，执行if语句，不符合时执行else语句或不执行

if else 语句
多个条件使用 if、elif、else 判断语句。
(elif可以写多个)

• 判断是互斥且有顺序的
• 条件判断中可以直接写input语句，简化代码量

随机数字

import random
num = random.randint(1, 10)

9.while循环

只要条件满足 会无限循环

i = 1
sum = 0
while i <= 100:
    sum += i
    i += 1
print(sum)

注意点

• while的条件需得到布尔类型，True表示继续循环，False表示循环结束
• 需要设置循环终止的条件
• 需要四格缩进和冒号（：）

9.1 补充知识-print输出不换行

默认print语句输出内容会自动换行：

print("Hello")
print("World")

输出：
Hello
World

在即将完成的案例中，我们需要使用print语句，输出不换行的功能，方式如下：

print("Hello", end='')
print("World", end='')

输出：
HelloWorld

ps：end=''是使用的方法传参功能。

9.2 补充知识-制表符\t

在字符串中，有一个特殊符号：\t，效果等同于在键盘上按下：Tab键。
它可以让我们的多行字符串进行对齐。
比如：

#制表符\t
print("Hello World")
print("itheima best")

print("Hello\tWorld")
print("itheima\tbest")

输出：
Hello World
itheima best
Hello	World
itheima	best

输出九九乘法表
11\tend=‘’
12\tend=‘’ 22\tend=‘’
13\tend=‘’ 23\tend=‘’ 33\tend=‘’

#九九乘法表
i = 1
while i <= 9:
    j = 1
    while j<=i:
        print(f"{
     j} * {
     i} = {
     j * i}\t", end='')
        j += 1
    i += 1
    print() #print输出一个空字符，就是输出一个换行

输出：
1 * 1 = 1	
1 * 2 = 2	2 * 2 = 4	
1 * 3 = 3	2 * 3 = 6	3 * 3 = 9	
1 * 4 = 4	2 * 4 = 8	3 * 4 = 12	4 * 4 = 16	
1 * 5 = 5	2 * 5 = 10	3 * 5 = 15	4 * 5 = 20	5 * 5 = 25	
1 * 6 = 6	2 * 6 = 12	3 * 6 = 18	4 * 6 = 24	5 * 6 = 30	6 * 6 = 36	
1 * 7 = 7	2 * 7 = 14	3 * 7 = 21	4 * 7 = 28	5 * 7 = 35	6 * 7 = 42	7 * 7 = 49	
1 * 8 = 8	2 * 8 = 16	3 * 8 = 24	4 * 8 = 32	5 * 8 = 40	6 * 8 = 48	7 * 8 = 56	8 * 8 = 64	
1 * 9 = 9	2 * 9 = 18	3 * 9 = 27	4 * 9 = 36	5 * 9 = 45	6 * 9 = 54	7 * 9 = 63	8 * 9 = 72	9 * 9 = 81	

10.for循环（遍历循环）

for循环的作用与while相同，但是功能相差很多：

• while循环的循环条件时自定义的，自行控制循环条件。
• for循环是一种“轮询”机制，是对一批内容进行“逐个处理”。
• for循环无法定义循环条件的。只能从被处理的数据集中，依次去除内容进行处理。

for循环的格式（例 遍历字符串）：

#定义字符串name
name = "itheima"
for x in name:  #name被称为待处理数据集
    print(x, end="")

输出：
itheima

range语句
语法中的：待处理数据集，严格来说，称之为：序列类型
序列类型指，其内容可以一个个依次取出的类型，包括字符串、列表、元组等。

range语句可以获得一个简单的数字序列
语法1：
range(num)
获取一个从0开始，到num结束的数字序列（不包含num本身）
例如range(5)取得的数据是：[0,1,2,3,4]

语法2：
range(num1, num2)
获得一个从num开始，到num2结束的数字序列（不包含num2本身）
如range(5, 10)取得的数据是：[5,6,7,8,9]

语法3：
range(num1, num2, step)
获得一个从num1开始，到num2结束的数字序列（不包含num2本身）
数字之间的步长，以step为准（step默认为1）
如range(5, 10, 2)取得的数据是：[5,7,9]

11.continue和break

无论是while循环或者是for循环，都是重复性的执行特定操作。
在这个重复过程中，或出现一些其他情况让我们不得不：

• 咱是跳过某次循环，直接进行下一次
• 提前退出循环，不在继续
  而continue和break用以对循环进行临时跳过和直接结束。

continue
continue关键字用于：中断本次循环，直接进入下一次循环。
而在嵌套循环中，continue只可以控制：他所在的循环临时中断

break
break关键字用于：直接结束循环
break可以用于：for循环和while循环，效果一致
而在嵌套循环中，break关键字同样只可以控制：它所在的循环结束

12. 函数

函数是组织好的，可重复使用的，用来实现特定功能的代码段。
例如，我们使用过的input(),print(),str(),int(),len()等都是python的内置函数

#函数的定义：
def 函数名(传入参数):
    函数体
    return 返回值

注意事项

• 参数如不需要，可以省略
• 返回值如不需要，可以省略
• 函数必须先定义后使用

函数的传入参数-传参定义
传入参数的功能是：在函数进行计算的时候，接收外部（调用时）提供的数据

#传参定义
def add(x, y):
    result = x + y
    print(f"{
     x} + {
     y} = {
     result}")

1. 函数定义中，提供的x和y，称之为：形式参数（形参），表函数声明将要使用2个参数
2. 参数之间使用逗号进行分隔
3. 函数调用中，提供的数字，例如add(5, 6)，称之为：实际参数（实参），表示函数执行时真正使用的参数值
4. 传入的时候，按照顺序传入数据，使用逗号分隔
5. 传入参数的数量是不受限制的，可以不使用参数，也可以仅使用任意N个参数

返回值的定义语法
程序中的返回值：

#return返回值
def add(a, b):
    result = a + b
    return result

r = add(5, 6)
print(r)

所谓“返回值”，就是程序中函数完成事情后，最后给调用者的结果。
在语法中，就是通过return关键字，想调用者返回数据。

注意事项

• 函数体在执行的时候，遇到return关键字就结束了，return后面的代码不会执行

None
没有return语句返回值的函数，实际上返回了一个特殊的字面量：None，其类型是<class’None =type’>

None作为一个特殊的字面量，用于表示：空、无意义，其有非常多的应用场景。

• 用在函数无返回值上
• 在if判断中，None等同于False，一般用于在函数中主动返回None，配合if判断做相关处理
• 用于声明无内容的变量上，使用None来代替具体值

例如：

#判断年龄函数
def check_age(age):
    if age >= 18:
        return "SUCCESS"
    else:
        return None

result = check_age(16)
if not result:
    #进入if表示result是None值，也就是False值，而not False就是Ture表示通过if条件（但是年龄检测并未通过）
    print("未成年，不可进入")

输出：
未成年，不可进入

函数的说明文档
为了便于理解函数，徐亚给函数添加说明文档，辅助理解函数的作用。
具体就是使用多行注释的形式，对函数进行说明解释

• 内容应该写在函数体之前
• 在PyCharm编写代码时，可以通过鼠标悬停，查看调用函数的说明文档

函数的嵌套调用

所谓函数嵌套调用指的是一个函数里面又调用了另外一个函数

#函数的嵌套
def func_b():
    print("---2---")

def func_a():
    print("---1---")

    func_b()

    print("---3---")

func_a()

输出：
---1---
---2---
---3---

变量的作用域
局部变量的作用：在函数体内部，临时保存数据，即当函数调用完成之后，则销毁局部变量
全局变量的作用：在函数体内、外都能生效的变量
例如：

#在函数内修改全局变量
num = 200

def test_a():
    print(f"test_a:{
     num}")

def test_b():
    num = 500        #新定义的局部变量，与全局变量num无关
    print(f"test_b:{
     num}")

test_a()
test_b()
print(num)

输出：
test_a:200
test_b:500
200

• 注意第三次输出，全局变量并不会被局部变量改变

global关键字
使用global关键字可以在函数内部声明变量为全局变量，如下所示：

#global关键字
num = 200

def test_a():
    print(f"test_a:{
     num}")

def test_b():
    global num       #设置内部定义的变量为全局变量
    num = 500        #新定义的局部变量，与全局变量num无关
    print(f"test_b:{
     num}")

test_a()
test_b()
print(num)

输出：
test_a:200
test_b:500
500

13.数据容器

python中的数据容器

一种可以容纳多份数据的数据类型，容纳的每一份数据称之为1个元素，每一个元素可以是任意类型的数据，如字符串、数字、布尔等。

数据容器主要分为五类：

• 列表（list）
• 元组（tuple）
• 字符串（str）
• 集合（set）
• 字典（dict）

列表的定义

基本语法：

# 字面量
[元素1, 元素2, 元素3, 元素4, ...]
# 字符串变量需要使用引号

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

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

列表内的每一个数据，称之为元素

注意： 列表可以一次存储多个数据，且可以为不同的数据类型，支持嵌套

列表的下表（索引）

列表元素的下标索引从前向后的方向，从0开始，依次递增
或者，可以反向索引，也就是从后向前：从-1开始，依次递减

如果列表是嵌套的列表，同样支持下标序索引，例如：

取出红色箭头所指的内层列表的元素：列表[1][1]

列表的查询功能（方法）

回忆：函数是一个封装的代码单元，可以提供特定功能。
在python中，如果将函数定义为class（类）的成员，那么函数会称之为：方法

# 函数
def add(x, y):
    return x + y

# 方法
class Student:
    
    def add(self, x, y):
        return x + y

方法和函数功能一样，有传入参数，有返回值，只是方法的使用格式不同：

# 函数的使用
num = add(1, 2)

# 方法的使用
student = Student()
num = student.add(1, 2)

index方法
功能：查找指定元素在列表的下标，如果找不到，报错ValueError

     语法：列表.index(元素)

注意：index就是列表对象（变量）内置的方法（函数）

列表的修改功能（方法）

1.修改特定位置（索引）的元素值：

     语法：列表[下标] = 值

2.插入元素：

     语法：列表.insert(下标, 元素），在指定的下标位置，插入指定的元素

3.追加元素：

     语法：列表.append（元素），将指定元素，追加到列表的尾部

4.追加元素方式2：

     语法：列表.extend（其他数据容器），将其他数据容器的内容取出，依次追加到列表尾部

5.删除元素：

     语法1：del 列表[下标]

     语法2：列表.pop(下标)，原理是将指定元素取出然后返回，所以可以使用变量接收返回值

6.删除某元素在列表中的第一个匹配项：

     语法：列表.remove(元素)

7.清空列表：

     语法：列表.clear()

8.统计某元素在列表内的数量：

     语法：列表.count(元素)

9.统计列表内，有多少元素：

     语法：len(列表)，可以得到一个int数字，表示列表内的元素数量

列表的特点

• 可以容纳多个元素（上限为2**63-1、 9223372036854775807个）
• 可以容纳不同类型的元素（混装）
• 数据是有序存储的（有下标序号）
• 允许重复数据存在
• 可以修改（增加或删除元素等）

列表的遍历 - while循环

将容器内的元素依次取出进行处理的行为，称之为：遍历、迭代

def list_while_func():
    """
    使用while循环遍历列表的演示函数
    :return: None
    """
    my_list = ['wang', 'luo', 'yue']
    index = 0 #初始下标为0
    while index < len(my_list):
        element = my_list[index]
        print(f"列表的第{
     index + 1}个元素：{
     element}")
        index += 1

list_while_func()

输出：
列表的第1个元素：wang
列表的第2个元素：luo
列表的第3个元素：yue

def list_for_func():
    """
    使用for循环遍历列表的演示函数
    :return: None
    """
    my_list = [1, 2, 3, 4, 5]
    print(f"列表的元素有：")
    for element in my_list:
        print(element, end='')

list_for_func()

输出：
列表的元素有：
wangluoyue

总结：

• for循环更简单，while循环更灵活
• for用于从容器内依次取出元素并处理，while用以任何需要循环的场景

14.元组

元组同列表一样，都是可以封装多个、不同类型的元素在内。
但最大的不同点在于：
元组一旦定义完成，就不可修改

定义元组（tuple）

元组定义：定义元组使用小括号，且使用逗号隔开各个数据，数据可以是不同的数据类型。

#定义元组字面量
(元素, 元素, ......, 元素)

#定于元组变量
变量名称 = (元素, 元素, ......, 元素)

#定义空元组
变量名称 = ()           #方式1
变量名称 = tuple()      #方式2

其中要注意元组中只有一个元素的时候：

# 定义3个元素的元组
t1 = (1, 'hello', True)

# 定义1个元素的元组
t2 = ("hello",)   #注意，必须带有逗号，否则不是元组类型

而且，元组也支持嵌套。

元组的相关操作

编号	方法	作用
1	index()	查找某个数据，如果数据存在，返回对应的下标，否则报错
2	count()	统计某个数据在当前元组出现的次数
3	len(元组)	统计元组内的元素个数

注意：

• 不可以修改元组的内容，否则会直接报错
• 可以修改元组内的list的内容（修改元素、增加、删除、反转等）

例如：

# 尝试修改元组内容（列表）
t1 = (1, 2, ['itheima', 'itcast'])
t1[2][1] = 'best'
print(t1)

输出：
(1, 2, ['itheima', 'best'])

元组多数特性和list一致，不同点在于不可修改的特性。

15.字符串（2）

尽管字符串看起来并不像：列表、元组那样，一看就是存放了许多数据的容器。
但不可否认的是，字符串同样也是数据容器的一员。

字符串是字符的容器，一个字符串可以存放任意数量的字符。

字符串的下标（索引）

和其他容器一样，字符串也可以通过下标进行访问

# 通过下标过去特定位置字符
name = "pycharm player"
print(name[0])
print(name[7])
print(name[-1])

输出：
p
 
r

同元组一样，字符串也是一个无法修改的容器。

字符串的常用操作

编号	方法	作用
1	字符串.index(字符串)	查找特定字符串的下表索引值
2	字符串.replace(字符串1， 字符串2)	将字符串内的全部：字符串1，替换为字符串2
3	字符串.split(分隔字符串)	按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表对象中
4	字符串.strip()	字符串的规整操作（去前后空格）
5	字符串.strip(字符串)	字符串的规整操作（去前后指定字符串）
6	字符串.count(字符串)	统计某个字符在当前字符串中出现的次数
7	len(字符串)	统计字符串的长度

注意：在方法2中，字符串本身不变，而是得到了一个新的字符串，方法3则是得到了一个列表

方法2：

# replace方法
name = "pycharm player"
new_name = name.replace('p', 'P')
print(name)
print(new_name)

输出：
pycharm player
Pycharm Player

方法3：

# split方法
my_str = 'hello python man'
list_str = my_str.split(' ')
print(f"将字符串{
     my_str}进行split切分后得到：{
     list_str},他的类型是：{
     type(list_str)}")

输出：
将字符串hello python man进行split切分后得到：['hello', 'python', 'man'],他的类型是：<class 'list'>

方法5
注意：strip(‘12’)实际上是清除字符串前后的‘1’和 ‘2’并不是固定的‘12’

# strip方法
my_str = '12hello python man21'
new_my_str = my_str.strip('12')
print(f"字符串{
     my_str}被 strip('12')后，结果为：{
     new_my_str}")

输出：
字符串12hello python man21被 strip('12')后，结果为：hello python man

字符串的遍历

同列表、元组一样，字符串也支持while和for循环进行遍历

# for循环遍历字符串
my_str = 'hello'
for i in my_str:
    print(f'字符串内的字符为：{
     i}')

输出：
字符串内的字符为：h
字符串内的字符为：e
字符串内的字符为：l
字符串内的字符为：l
字符串内的字符为：o

字符串的特点

作为数据容器，字符串有如下特点：

• 只可以存储字符串
• 长度任意（取决于内存大小）
• 支持下表索引
• 允许重复字符串存在
• 不可以修改
• 支持for循环

16.序列

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

序列的常用操作 - 切片

序列支持切片操作，即从一个序列中，取出一个子序列

# 切片语法
序列[起始下标:结束下标:步长]

表示从序列中，在指定位置开始，按照步长依次取出元素，直到指定位置结束，得到一个新序列：

• 起始下标表示从何处开始，可以留空，留空视作从头开始
• 结束下标（不含）表示何处结束，可以留空，留空视作截取到结尾
• 步长表示，依次取出元素的间隔。例如：步长n表示，每跳过n-1个元素取一个（其中，步长为负数表示反向取，此时起始下标和结束下标也要反向标记）
• 此操作不会影响到序列本身，而是会得到一个新的序列

<