Python
一、导学
- Pthon语言基础入门
- Pthon语言高阶加强
- 大数据分析PySpark
二、 初识Python
- 你好Python程序
-
print("Hello World!!") >>Hello World!!
！输入的双引号和括号为英文字符
三、 Python基础语法
（一） 字面量
1. 定义：在代码中，被写下来的固定的值，称之为字面量。
2. 常用的6种值的类型
| 类型 | 描述 | 说明 |
| 数字（Number） | 支持（4种子类型）
|
|
| 字符串（String） | 描述文本的一种数据类型 | 字符串（string）由任意数量的字符组成 |
| 列表（List） | 有序的可变序列 | Python中使用最频繁的数据类型，可有序记录一堆数据 |
| 元组（Tuple） | 有序的不可变序列 | 可有序记录一堆不可变的Python数据集合 |
| 集合（Set） | 无序不重复集合 | 可无序记录一堆不重复的Python数据集合 |
| 字典（Dictionary） | 无序Key-Value集合 | 可无序记录一堆Key-Value型的Python数据集合 |
3. 字符串
！Python中，字符串需要用双引号包围；
！被双引号包围的都是字符串
-
666 13.14 "黑马程序员" print( 666 ) print( 13.14 ) print( "黑马程序员" ) >>666 >>13.14 >>"黑马程序员"
（二） 注释
1. 单行注释
# 我是单行注释
print( "黑马程序员" )！规范：#号和注释内容一般建议以一个空格隔开
2. 多行注释
"""
我是多行注释
666
13.14
"黑马程序员"
"""
print( 666 )
print( 13.14 )
print( "黑马程序员" )（三） 变量
1. 定义：程序运行时，能储存计算结果或表示值的抽象概念。
简单的说，变量就是在程序运行时，记录数据用的
2.定义格式：
变量名称 = 变量的值
# 定义变量
money = 5000
# print输出变量
print( " 钱包还有：" , money )
>> 钱包还有： 5000
# 买了东西，花费10元
money = money - 10
print( "买了冰淇淋花费10元，还剩余：" , money , "元" )
>>买了冰淇淋花费10元，还剩余： 4990 元！变量值可变
$练习：
（四） 数据类型
1. type()语句【具有返回值】
1）语法：
type(被查看类型的数据)
2）使用方法：
a = type( 666 )
print( a )
print( type( 13.14 ) )
name = "黑马程序员"
name_type = type( name )
print( name_type )
>> <class 'int'>
>> <class 'float'>
>> <class 'str'>2. 变量无类型，查看变量的类型实际上查看的是变量存储数据的类型
！字符串变量：不是字符串是变量，而是变量存储了字符串
（五） 数据类型转换
1. 常见的转换语句
| 语句（函数） | 说明 |
| int( x ) | 将x转换为一个整数 |
| float( x ) | 将x转换为一个浮点数 |
| str( x ) | 将对象x转换为字符串 |
！此三种语句具有返回值
# 将数字类型 -> 字符串类型
num_str = str( 11 )
print( type( num_str ) , num_str )
float_str = str( 13.14 )
print( type( float_str ) , float_str )
>> <class 'str'> 11
>> <class 'str'> 13.14# 将字符串类型 -> 数字类型
num = int( "11" )
print( type( num ) , num )
num2 = float( "13.14" )
print( type( float ) , num2 )
>> <class 'int'> 11
>> <class 'float'> 13.14！想要将字符串转换成数字，必须要求字符串内的内容都是数字
num3 = int ( "黑马程序员" )
print( type( num3 ) , num3 )
>> ValueError: invalid literal for int() with base 10: '黑马程序员'！浮点数转整数会丢失精度
# 整数 -> 浮点数
float_num = float( 11 )
print( type( float_num ) , float_num )
>> <class 'float'> 11.0
# 浮点数 -> 整数
int_num = int( 13.14 )
print( type( int_num ) , int_num )
>> <class 'int'> 13（六）标识符
1. 定义：用户在编程时所用的一系列名字，用于给变量、类、方法等命名。
2. 命名规则：
内容限定（英文，中文，数字，下划线_）
！数字不可开头
大小写敏感
不可使用关键字
3. 命名规范：
见名知义
下划线命名法
英文字母全小写
（七） 远算符
1. 算术运算符：+、-、*、/、//、%、**（指数）
2. 赋值运算符：=
3. 复合赋值运算符：+=、-=、*=、/=、//=、%=、**=
（八） 字符串扩展
1. 3种定义方式
1）定义形式：
① 单引号定义法：
name = '黑马程序员'
②双引号定义法：
name = "黑马程序员"
③三引号定义法：
name = """黑马程序员"""
*支持换行操作，使用变量接收它，则为字符串；不使用变量接收，则为多行注释
# 单引号定义法，使用单引号进行包围
name = '黑马程序员'
print( type(name) )
# 双引号定义法，写法和多行注释是一样的
name = "黑马程序员"
print( type(name) )
# 三引号定义法，写法和多行注释是一样的
name = """
我是
黑马
程序员
"""
print( type(name) )
>> <class 'str'>
>> <class 'str'>
>> <class 'str'>
2）字符串的引号嵌套
①单引号法，可以内含双引号；
②双引号定义法，可以内含单引号；
②可以使用转义字符（\）来将引号解除效用，变成普通字符串。
# 字符串内，包含双引号
name = '"黑马程序员"'
print( name )
# 字符串内，包含单引号
name = "'黑马程序员'"
print( name )
# 使用转义字符（\）解除引号的效用
name = "\"黑马程序员\""
print( name )
name = '\'黑马程序员\''
print( name )
>> "黑马程序员"
>> '黑马程序员'
>> "黑马程序员"
>> '黑马程序员'
2. 字符串拼接
1）通过+号进行拼接
-
name = "黑马程序员" -
print( "我的名字是：" + name + "我可以教大家IT技能" ) -
>> 我的名字是：黑马程序员我可以教大家IT技能
！无法和非字符串类型进行拼接
3. 字符串格式化
1）“%占位符”%变量
2）常用占位符
字符串：%s
整数： %d
浮点数：%f
3）数字精度控制
辅助符号“m.n”来控制数据的宽度和精度
m ：控制宽度，要求是数字（很少使用），设置的宽度小于数字本身，不生效
.n：控制小数点精度，要求是数字，会进行小数的四舍五入
%5d：表示将整数的宽度控制在5位，如数字11，被设置为5d，就会变成：[空格][空格][空格]11，用三个空格补足宽度
%5.2f：表示将宽度控制为5，将小数点精度设置为2
小数点和小数部分也算入宽度计算。如：对11.345设置为%7.2后，结果是：[空格][空格]11.35。2个空格补足宽度，小数部分限制2位精度，四舍五入为.35
%.2f：表示不限制宽度，只设置小数点精度为2，如11.345设置为%.2f，结果是11.35
num1 = 11
num2 = 11.345
print( "数字11宽度限制5，结果：%5d" % num1 )
print( "数字11宽度限制1，结果：%1d" % num1 )
print( "数字11.345宽度限制7，小数精度2，结果：%7.2f" % num2 )
print( "数字11.345不限制宽度，小数精度2，结果：%.2f" % num2 )
>> 数字11宽度限制5，结果： 11 # 宽度5，补了3个空格
>> 数字11宽度限制1，结果：11 # 宽度小于数字本身，无影响
>> 数字11.345宽度限制7，小数精度2，结果： 11.35
# 宽度7，补了2个空格，小数精度2，四舍五入后为.35
>> 数字11.345不限制宽度，小数精度2，结果：11.35
# 不限制宽度，小数点后四舍五入后为.354）快速写法
语法：
f"内容{变量}"
name = "传智播客"
set_up_year = 2006
stock_price = 19.99
print( f"我是{name}，我成立于{set_up_year}。我今天的股票价格是：{stock_price}" )
>> 我是传智播客，我成立于2006。我今天的股票价格是：19.99
# 不做精度控制，原样输出！以上字符串格式化均可用于表达式格式化
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'>$练习：
（九）数据输入
1. 语法
input();
2. 使用：
使用input()语句可以从键盘获取输入
使用一个变量接收（存储）input语句获取的键盘输入数据即可
数据输出：print
数据输入：input
print( "请告诉我你是谁？" )
name = input()
print( "GET！！你是：%s" % name )
>> 请告诉我你是谁？
>> XUANseyo
>> GET！！你是：XUANseyo! input()语句可以在要求使用者输入内容之前，输出提示内容的
-
name = input( "你是谁？" ) print( "GET！！你是：%s" % name ) >> 你是谁？XUANseyo >> GET！！你是：XUANseyo
！无论input()输入什么，其都会自动转为字符串类型，我们要自行进行数据类型转换
-
num = input( "你的银行卡密码是：" ) print( "你的银行卡密码的类型是：" , type( num ) ) >> 你的银行卡密码是：123456 >> 你的银行卡密码的类型是： <class 'str'>
$练习：
四、 Python判断语句
（一） 布尔类型和比较运算符
1. 布尔类型：判断结果
True：表示真（是、肯定）
False：表示假（否、否定）
-
# 定义变量存储布尔类型的数据 bool_1 = True bool_2 = False print( f"bool_1变量的内容是：{ bool_1 }，类型为：{ type( bool_1 ) }" ) print( f"bool_2变量的内容是：{ bool_2 }，类型为：{ type( bool_2 ) }" ) >> bool_1变量的内容是：True，类型为：<class 'bool'> >> bool_2变量的内容是：False，类型为：<class 'bool'>
2. 比较运算和比较运算符：
==、!=、>、<、>=、<=
（二） if语句的基本格式
1. if语句基本格式：
if 要判断的条件：
条件成立时，要做的事情
！首行缩进确定代码块归属
-
age = 30 if age >= 18: print( "我已经成年了。" ) print( f"已经{ age }岁了啊！" ) print( "时间过得真快啊！" ) >> 我已经成年了。 >> 已经30岁了啊！ >> 时间过得真快啊！
# 判断语句的结果必须为布尔类型的True或False
True会执行if内的代码语句
False则不会执行
-
age = 10 if age >= 18: print( "我已经成年了。" ) print( f"已经{ age }岁了啊！" ) print( "时间过得真快啊！" ) >> 时间过得真快啊！
$练习：
（三） if else 语句
1. 基本格式：
if 条件 ：
满足条件时要完成的事1
满足条件时要完成的事2
……
else：
不满足条件时要完成的事1
不满足条件时要完成的事2
……
-
print( "欢迎来到黑马儿童游乐场，儿童免费，成人收费！" ) age = input( "请输入您的年龄：" ) if int(age) >= 18 : print( "您已成年，游玩需补票10元" ) else : print( "您未成年，无需补票" ) print( "祝您游玩愉快！！！" ) >> 欢迎来到黑马儿童游乐场，儿童免费，成人收费！ >> 请输入您的年龄：17 >> 您未成年，无需补票 >> 祝您游玩愉快！！！
$练习：
"""
演示if else练习题：我要买票吗
"""
# 定义键盘输入获取身高数据
height = int(input("请输入你的身高（cm）："))
# 通过if进行判断
if height > 120:
print("您的身高超出120CM，需要买票，10元。")
else:
print("您的身高低于120CM，可以免费游玩。")
print("祝您游玩愉快")（四） if elif else 语句
1. 基本格式：
if 条件1 :
条件1满足时要完成的事
条件1满足时要完成的事
……
elif 条件2::
条件2满足时要完成的事
条件2满足时要完成的事
……
elif 条件n:
条件n满足时要完成的事
条件n满足时要完成的事
……
else:
所有条件不满足时要完成的事
所有条件不满足时要完成的事
……
-
print("欢迎来到黑马动物园！！") height = int(input("请输入你的身高：")) vip_level = int(input("请输入您的vip级别（1~5）：")) if height < 120 : print("您的身高小于120cm，可以免费游玩") elif vip_level > 3 : print("您的vip级别大于3，可以免费游玩") else : print("不好意思，所有条件均不符合，需要购票10元") print("祝您游玩愉快") >> 欢迎来到黑马动物园！！ >> 请输入你的身高：150 >> 请输入您的vip级别（1~5）：5 >> 您的vip级别大于3，可以免费游玩 >> 祝您游玩愉快
$练习：
"""
演示if elif else练习题：猜猜心里数字
"""
# 定义一个变量数字
num = 5
# 通过键盘输入获取猜想的数字，通过多次if 和 elif的组合进行猜想比较
if int(input("请猜一个数字：")) == num:
print("恭喜第一次就猜对了呢")
elif int(input("猜错了，再猜一次：")) == num:
print("猜对了")
elif int(input("猜错了，再猜一次：")) == num:
print("恭喜，最后一次机会，你猜对了")
else:
print("Sorry 猜错了")（五） 判断语句的嵌套
1. 基本格式
if 条件1 ：
满足条件1时要完成的事1
满足条件1时要完成的事2
……
if条件2：
满足条件2做的事情1
满足条件2做的事情2
……
2. 嵌套的关键点：空格缩进
通过空格缩进，来决定语句之间的：层次关系
（六） 实战案例
-
import random num = random.randint(1,10) m = int(input("第一次才得数字：")) if num == m : print ("猜对啦！") else : if num > m: print("猜小了！") else : print("猜大了！") m2 = int(input("第二次猜测的数字：")) if m2 == num: print("第二次猜对了！") elif num > m2: print("第二次猜小了！") elif num < m2: print("第二次猜大了") guess_num = int(input("第三次输入你要猜测的数字：")) if guess_num == num: print("第三次猜中了") else: print("三次机会用完了，没有猜中。")
五、 Python循环语句
（一） while循环的基本语法
1. 基本格式
while 条件：
条件满足时，做的事情1
条件满足时，做的事情2
…（省略）…
- 只要条件满足，会无限循环执行
- 条件需要布尔类型结果
$练习：
"""
演示while循环基础练习题：求1-100的和
"""
sum = 0
i = 1
while i<=100:
sum += i
i += 1
print(f"1-100累加的和是：{sum}")（二） while循环的基础案例
"""
演示while循环的基础案例 - 猜数字
"""
# 获取范围在1-100的随机数字
import random
num = random.randint(1, 100)
# 定义一个变量，记录总共猜测了多少次
count = 0
# 通过一个布尔类型的变量，做循环是否继续的标记
flag = True
while flag:
guess_num = int(input("请输入你猜测的数字:"))
count += 1
if guess_num == num:
print("猜中了")
# 设置为False就是终止循环的条件
flag = False
else:
if guess_num > num:
print("你猜的大了")
else:
print("你猜的小了")
print(f"你总共猜测了{count}次")
（三） while循环的嵌套应用
1. 基本格式：
while 条件1：
条件1满足时，做的事情1
条件1满足时，做的事情2
…（省略）…
while 条件2：
条件2满足时，做的事情1
条件2满足时，做的事情2
…（省略）…
（四） while循环的嵌套应用
补充：
1. print输出不换行
-
print("Hello",end=' ') print("World!",end='') >> Hello World!
2. 制表符/t
-
print("学号\t姓名\t语文\t数学\t英语") print("2022001\t小王\t99\t\t88\t\t0") print("2022002\t小周\t92\t\t45\t\t93") print("2022008\t小黄\t77\t\t82\t\t100")
"""
演示使用while的嵌套循环
打印输出九九乘法表
"""
# 定义外层循环的控制变量
i = 1
while i <= 9:
# 定义内层循环的控制变量
j = 1
while j <= i:
# 内层循环的print语句，不要换行，通过\t制表符进行对齐
print(f"{j} * {i} = {j * i}\t", end='')
j += 1
i += 1
print() # print空内容，就是输出一个换行（五） for循环的基础语法
1. 基础语法
for循环就是将“待办事项”逐个完成的循环机制
- while循环的循环条件是自定义，自行控制循环条件
- for循环是一种“轮询”机制，是对一批内容进行逐个处理
！for循环无法定义循环条件，只能从被处理的数据集中，依次取出内容进行处理
1） 基本格式：
for 临时变量 in 待处理的数据集：
循环满足条件时执行的语句
$练习：
"""
演示for循环的练习题：数一数有几个a
"""
# 统计如下字符串中，有多少个字母a
name = "itheima is a brand of itcast"
# 定义一个变量，用来统计有多少个a
count = 0
# for 循环统计
# for 临时变量 in 被统计的数据:
for x in name:
if x == "a":
count += 1
print(f"被统计的字符串中有{count}个a")
2. range语句
1） 功能：获得一个数字序列（可迭代类型的一种）
2） 语法格式：
range（num）
获取一个从0开始，到num结束的数字序列
range（num1，num2）
获取一个从num1开始，到num2结束的数字序列（不含num2本身）
range（num1，num2，step）
获得一个从num1开始，到num2结束的数字序列（不含num2本身）
数字之间的步长，以step为准（step默认为1）
$练习：
3. 变量作用域
（六）for循环的嵌套应用
1. 基本格式：
for 临时变量 in 待处理的数据集：
循环满足条件时执行的语句1
循环满足条件时执行的语句2
……
for 临时变量 in 待处理的数据集：
循环满足条件时执行的语句1
循环满足条件时执行的语句1
$练习：
"""
演示for循环打印九九乘法表
"""
# 通过外层循环控制行数
for i in range(1, 10):
# 通过内层循环控制每一行的数据
for j in range(1, i + 1):
# 在内层循环中输出每一行的内容
print(f"{j} * {i} = {j * i}\t", end='')
# 外层循环可以通过print输出一个回车符
print()（七） 循环中断：break和continue
1. continue关键字作用：中断本次循环，直接进入下一次循环【for循环和while循环即可使用】
2. break关键字作用：所在循环永久中断【for循环和while循环即可使用】
（八） 综合案例
六、 Python函数
（一） 函数介绍
1. 函数：是组织好的，可重复使用的，用来实现特定功能的代码段。
eg. len()：实现统计长度这一特定功能的代码段。
2. 函数好处：
* 将功能封装在函数内，可随时随地重复利用
* 提高代码的复用性，减少重复代码，提高开发效率
（二） 函数定义
1. 基本语法：
（1） 函数定义
def 函数名 （传入函数）：
函数体
return 返回值
（2） 函数调用
函数名（参数）
！参数可省略
！返回值可省略
！函数必须先定义后使用
$练习：
-
def printWelcome (): print("欢迎来到黑马程序员！") print("请出示48小时核酸检测证明！") printWelcome()
（三） 函数参数
1. 传入参数的功能：在函数调用时，接受外部提供的数据
！参数之间按顺序传入；使用，进行分隔
$练习：
-
def printWelcome(x): print("欢迎来到黑马程序员！请出示48小时核酸检测证明！") if x <= 37.5: print(f"体温测量中，您的体温是：{x}，体温正常，请进！") else: print(f"体温测量中，您的体温是{x}，需要隔离！") y = int(input("请输入您的体温：")) printWelcome(y)
（四） 函数返回值
1. 通过return关键字，可向调用者返回数据
2.. None类型：
（1） None，其类型是<class ’NoneType’>
（2） 无返回值的函数，实际上是返回了None这个字面量
（3） 使用：
- 用于函数返回值中【空】
- 用于if判断【None等同于False】
- 用于声明无内容的变量上
（五） 函数说明文档
1. 函数说明文档：对函数进行说明解释，帮助更好地理解函数
2.. 定义语法：
def func（x，y）
"""
函数说明
：param x：参数x的说明
：param x：参数x的说明
：return：返回值的说明
"""
函数体
return 返回值
（六） 函数嵌套使用
1. 函数嵌套：在一个函数中，调用另一个函数。
2. 执行流程：
函数a中执行到调用函数b的语句，会将b全部执行；完成后，继续执行函数a的剩余内容
（七） 变量的作用域
1. 变量作用域：变量的作用范围
2.. 局部变量：定义在函数体内部的变量，只在函数体内部生效
局部变量作用：在函数体内部，临时保存数据，即当函数调用完成后，销毁局部变量
3. 全局变量：在函数体内外都能生效的变量
4. global关键字：可使函数内部声明变量为全局变量
（八） 综合案例
-
money = 5000000 name = None def menu(): name = input("您好！请输入客户姓名：") print("您好，请问您需要什么服务呢？") print("输入1：查询余额") print("输入2：存款") print("输入3：取款") n = int(input("请输入功能号：")) if n == 1: check(money) elif n == 2: x = int(input("请输入您想存入的金额：")) deposit(x, money) elif n == 3: y = int(input("请输入您想取出的金额：")) withdraw(y, money) def check(money): print(f"您好！您的余额为：{money}") menu() def deposit(x, money): money1 = x + money print(f"您好，存款成功后，您的余额为：{money1}") menu() def withdraw(x, money): money2 = money - x print(f"您好，取款成功后，您的余额为：{money2}") menu() menu()
七、 Python数据容器
（一） 数据容器入门
1. 数据容器：一种可以容纳多份数据的数据类型，容纳的每一份数据称之为一个元素。每一个元素，可以是任意类型的数据，如字符串、数字、布尔等。
2.. 种类：list（列表）、tuple（元组）、str（字符串）、set（集合）、dict（字典）
（二） 数据容器：list（列表）
1. 定义
（1） 基本语法：
# 字面量
[元素1 ，元素2 ，元素3，……]
# 定义变量
变量名称 = [元素1 ，元素2 ，元素3，……]
# 定义空列表
变量名称 = []
变量名称 = list（）
（2） 元素：列表中的每个数据
！ 列表可以一次存储多个数据，且可以为不同类型，支持嵌套
2. 列表的下标索引
（1） 类型：正向：从前向后，从0开始，依次递增
反向：从后向前，从-1开始，依次递减
（2） 使用：
列表[下标]
！ 下标超出范围，则无法取出元素，并且会报错
3. 列表的常用操作（方法）
* 函数：封装的代码单元，可提供特定功能。
如将函数定义为class（类）的成员，则称函数为方法。
| 编号 | 关键字 | 使用方法 | 作用 |
| 1 | index | 列表.index（元素） | 查找指定元素在列表中的下标，找不到则报错ValueError |
| 2 | len | len（列表） | 统计容器中有多少元素 |
| 3 | count | 列表.count（元素） | 统计此元素在列表中出现的次数 |
| 4 | del | del 列表[下标] | 删除列表指定的下标元素 |
| 5 | pop | 列表.pop[下标] | 删除列表指定的下标元素 |
| 6 | remove | 列表.remove（元素） | 从前向后，删除此元素的第一个匹配项 |
| 7 | append | 列表.append（元素） | 向列表中追加一个元素 |
| 8 | extend | 列表.extend（容器） | 将数据容器中的内容依次取出，追加到列表尾部 |
| 9 | insert | 列表.insert（下标，元素） | 在指定下标处，插入指定的元素 |
| 10 | clear | 列表.clear（） | 清空列表 |
4. 列表的特点
- 可容纳多个元素
- 可容纳不同类型的元素
- 数据是有序存储的
- 允许重复数据存在
- 可进行增删查改
$练习：
-
age = [21, 25, 21, 23, 22, 20] age.append(31) print(age) age.extend([29, 33, 30]) print(age) x = age[0] y = age[-1] print(x, y) a = age.index(31) print(a)
（三） list（列表）的遍历
* 遍历：将容器内的元素依次取出，并处理
1. 使用while遍历
- 可以指定循环条件，自行控制
- 可以通过条件控制做到无限循环
- 适用于任何想要循环的场景
2. 使用for遍历
- 不可以指定循环条件，只可以一个个从容器内取出数据
- 理论上不可以无限循环，因为被遍历的容器容量不是无限的
- 适用于遍历数据容器的场景或简单的固定次数循环场景
$练习：
-
L = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] l1 = list() l2 = list() i = 0 # 取出偶数 while i < len(L): if L[i] % 2 == 0: l1 . append(L[i]) i = i + 1 else: i = i + 1 print(f"通过while循环，从列表：{L}，中取出偶数，组成新列表{l1}") for j in L: if j % 2 == 0: l2 . append(j) print(f"通过for循环，从列表：{L}，中取出偶数，组成新列表{l2}")
（四） 数据容器：tuple（元组）
* 元组一旦定义，不可进行修改
1. 元组的定义
（1） 基本语法：
# 字面量
（元素1 ，元素2 ，元素3，……）
# 定义变量
变量名称 =（元素1 ，元素2 ，元素3，……）
# 定义空列表
变量名称 = （）
变量名称 =tuple（）
！ 元组即使只含有一个数据，这个数据后也要添加，也可进行嵌套
2. 元组的操作（方法）
| 编号 | 关键字 | 使用方法 | 作用 |
| 1 | index | index（） | 查找指定数据在元组中的下标，找不到则报错 |
| 2 | len | len（元组） | 统计元组内有多少元素 |
| 3 | count | count（） | 统计某个数据在元组中出现的次数 |
！ 不可修改元组内容，否则直接报错
！ 可修改元组内list的内容
！ 不可以替换元组内list为其他list或其他类型
3. 元组的特点
- 可容纳多个元素
- 可容纳不同类型的元素
- 数据是有序存储的
- 允许重复数据存在
- 可进行增删查改
- 可进行循环
- 不可修改
$练习：
-
T = ('周杰伦', 11, ['football', 'music']) a = T.index(11) n = T[0] print(a,n) del T[2][0] T[2].append('coding') print(T)
（五） 数据容器：str（字符串）
1. 字符串
字符的容器，一个字符串可以存放任意数量的字符。
2. 字符串的下标（索引）
- 从前向后，下标从0开始
- 从后向前，下标从-1开始
！ 字符串是一个无法修改的数据容器
！ 如果要修改，则会得到一个新的字符串，旧的字符串是无法修改的
3. 字符串的常用操作
| 编号 | 关键字 | 使用方法 | 作用 |
| 1 | 字符串[下标] | 根据下标索引取出特定位置字符 | |
| 2 | index | 字符串.index（字符串） | 查找给定字符的第一个匹配项的下标 |
| 3 | replace | 字符串.replace（字符串1，字符串2） | 将字符串内的全部字符串1，替换为字符串2 ！不会改变原字符串，而是得到一个新的字符串 |
| 4 | split | 字符串.split（字符串） | 按照给定字符串，对字符串进行分割 ！不会改变原字符串，而是得到一个新的列表 |
| 5 | strip | 字符串.strip（） 字符串.strip（字符串） | 移除首尾的空格和换行符或指定字符串 |
| 6 | count | 字符串.count（字符串） | 统计字符串内某字符串的出现次数 |
| 7 | len | len（字符串） | 统计字符串的字符个数 |
4. 字符串的特点
- 只可以存储字符串
- 长度任意
- 支持下标索引
- 允许重复的字符串出现
- 不可以修改
- 支持循环
$练习：
-
S = "itheima itcast boxuegu" n = S.count("it") print(f"字符串{S}中有{n}个it字符") S1 = S.replace(" ", "|") print(f"字符串{S}，被替换空格后，结果{S1}") L = S1.split("|") print(f"字符串{S}，按照“|”分割后，得到{L}")
（六） 数据容器的切片
1. 序列
内容连续、有序、可使用下标索引的一类数据容器。（如列表、元组、字符串等）
2. 切片
（序列的常用操作）从一个序列中，取出一个子序列
3. 基本语法
序列[起始下标：结束下标：步长]
* 表示从序列中，从指定位置开始，依次取出指定元素，到指定位置结束，得到一个新序列
* 起始下标表示从何处开始，可以留空，留空视作从头开始
* 结束下标（不含）表示何处结束，可以留空，留空视作截取到结尾
* 步长表示，依次取元素的间隔
- 步长1表示，一个个取元素
- 步长2表示，每次跳过1个元素取
- 步长N表示，每次跳过N-1个元素取
- 步长为负数表示，反向取（注意，起始下标和结束下标也要反向标记）
$练习：
-
S = "万过薪月，员序程马黑来，nohtyP学" # 使用“切片” new_S = S[9:4:-1] print(new_S) # 使用字符串常用操作 i = -9 S1 = S.replace("来", "") S2 = S1.split(",") print(S2) new_S1 = S2[0][9:4:-1] print(new_S1)
（七） 数据容器：set（集合）
1. 集合的基本语法
# 定义集合字面量
（元素，元素，……，元素）
# 定义集合变量
变量名称 = {元素，元素，……，元素}
# 定义空集合
变量名称 = set（）
！ 去重且无序，无法保证顺序与创建的时候一致
！ 不支持：下标索引访问，因此不支持while循环
补充：
定义：
列表[] 可修改、支持重复元素且有序
元组（） 不可修改、支持重复元素且有序
字符串“” 不可修改、支持重复元素且有序
集合{} 可修改、不支持重复元素、无序
2. 集合的常用功能
| 编号 | 关键字 | 使用方法 | 作用 |
| 1 | add | 集合.add（元素） | 集合内添加一个元素 |
| 2 | remove | 集合.remove（元素） | 移除集合内指定的元素 |
| 3 | pop | 集合.pop（） | 从集合中随机取出一个元素 |
| 4 | clear | 集合.clear（） | 将集合清空 |
| 5 | difference | 集合1.difference（集合2） | 得到一个新集合，内含2个集合的差集 原有的2个集合内容不变 |
| 6 | update | 集合1.difference_update（集合2） | 在集合1中，删除集合2中存在的元素 集合1被修改，集合2不变 |
| 7 | union | 集合1.union（集合2） | 得到1个新集合，内含2个集合的全部元素原有的2个集合内容不变 |
| 8 | len | len（集合） | 得到一个整数，记录了集合的元素数量 |
3. 集合的特点
- 可以容纳多个数据
- 可以容纳不同类型的数据（混装）
- 数据是无序存储的（不支持下标存储）
- 不允许重复数据存在
- 可以修改
- 支持for循环，不支持while循环
$练习：
-
my_list = ['黑马程序员','传智播客','黑马程序员','传智播客','itheima','itcast','itheima','itcast','best'] S = set() for i in my_list: S.add(i) print(f"有列表：{my_list}") print(f"存入集合后结果：{S}")
（八） 数据容器：dict（字典、映射）
1. 字典的基本语法
# 定义字典字面量
{key：value，key：value，……，key：value}
# 定义字面变量
my_dict = {key：value，key：value，……，key：value}
# 定义空字典
my_dict = {}
my_dict = dict{}
！ 每个元素均为键值对，key和value可以为任意类型数据（key不可为字典）
！ key不可重复，重复会对原有数据覆盖
！ 不可以使用下标索引，但可通过key值取得对应的value，不可使用while循环
！ 字典可嵌套
2. 字典的常用操作
| 编号 | 关键字 | 使用方法 | 作用 |
| 1 | 字典[Key] | 获取指定Key对应的Value值 | |
| 2 | 字典[Key] = Value | 添加或更新键值对 | |
| 3 | pop | 字典.pop（Key） | 取出Key对应的Value并在字典内删除此Key的键值对 |
| 4 | clear | 字典.clear（） | 清空字典 |
| 5 | keys | 字典.keys（） | 获取字典的全部Key，可用于for循环遍历字典 |
| 6 | len | len（字典） | 计算字典内的元素数量 |
3. 字典的特点
- 可以容纳多个数据
- 可以容纳不同类型的数据（混装）
- 不支持下标索引
- 可以修改
- 支持for循环，不支持while循环
$练习：
-
D = { "王力鸿":{"部门":"科技部","工资":3000,"级别":1}, "周婕纶":{"部门":"市场部","工资":5000,"级别":2}, "凌俊杰":{"部门":"市场部","工资":7000,"级别":3}, "张雪有":{"部门":"科技部","工资":4000,"级别":1}, "牛德华":{"部门":"市场部","工资":6000,"级别":2} } keys = D.keys() print(D) for key in keys: if D[key]["级别"] == 1: D[key]["工资"] = D[key]["工资"] + 1000 print(D)
扩展：数据容器的对比总结
| 列表 | 元组 | 字符串 | 集合 | 字典 | |
| 元素数量 | 支持多个 | 支持多个 | 支持多个 | 支持多个 | 支持多个 |
| 元素类型 | 任意 | 任意 | 仅字符 | 任意 | Key：除字典外任意类型 Value：任意类型 |
| 下标索引 | ✓ | ✓ | ✓ | × | × |
| 重复元素 | ✓ | ✓ | ✓ | × | × |
| 可修改性 | ✓ | × | × | ✓ | ✓ |
| 数据有序 | ✓ | ✓ | × | × | × |
| 使用场景 | 可修改、可重复的一批数据的记录 | 不可修改、可重复的一批数据的记录 | 一串字符的记录 | 不可重复的数据记录 | 以Key检索Value的数据记录 |
（九） 数据容器的通用操作
| 序号 | 功能 | 描述 |
| 1 | for循环 | 遍历容器（字典是遍历key） |
| 2 | max（） | 容器内最大元素 |
| 3 | min（） | 容器内最小元素 |
| 4 | len（） | 容器内元素个数 |
| 5 | list（） | 转换为列表 |
| 6 | tuple（） | 转换为元组 |
| 7 | str（） | 转换为字符串 |
| 8 | set（） | 转换为集合 |
| 9 | sorted（序列，[reverse = True]） | 排序，得到一个排好序的列表 reverse = True表示“降序” |
（十）综合案例
-
# 幸运数字6： # 1. 输入任意数字，如数字8，生成nums列表，元素值为1-8， # 2. 从中选取幸运数字（能被6整除）移动到新列表lucky # 3. 打印nums和lucky n = int(input("请输入您所想的数字：")) i = 1 j = 0 nums = list() lucky = list() print(n) while i <= n: nums.append(i) i = i + 1 print(f"nums列表为：{nums}") for j in nums: if j % 6 == 0: lucky.append(j) j = j + 1 print(f"lucky列表为：{lucky}")
-
# 列表嵌套： # 3个教室[[],[],[]] # 8名讲师['A','B','C','D','E','F','G','H'] # 随机分配 import random classroom = [[],[],[]] teacher = ['A','B','C','D','E','F','G','H'] j = random.randint(0,2) for i in teacher: classroom[j].append(i) j = random.randint(0,2) print(f"分配后为：{classroom}")
八、 函数进阶
（一） 函数多返回值
- 按照返回值的顺序，写对顺序的多个变量接收即可
- 变量之间用逗号隔开
- 支持不同类型的数据return
-
def test_return(): return 1,2 x,y = test_return() print(x) print(y) >>1 >>2
（二） 函数的多种传参方式
函数参数种类：根据使用方式不同：分为以下4种
1. 位置参数
- 根据函数定义的参数位置来传递参数
！ 传递的参数和定义的参数的顺序及个数必须一致
2. 关键字参数
- 函数调用时通过键值对的形式传递参数
！ 函数调用时，如果有位置参数时，位置参数必须在关键字参数的前面，但关键字参数之间不存在先后顺序
3. 缺省参数
- 也称默认参数，用于定义函数，为函数提供默认值，调用函数时可不传该默认参数的值
！ 所有位置参数必须出现在默认参数前，包括函数定义和调用
！ 函数调用时，如果为缺省参数传值则修改默认参数值，否则使用这个默认值
4. 不定长参数
- 也称可变参数，用于不确定调用的时候会传递多少个参数（不传参也可以）的场景。
！ 当调用函数时不确定参数个数时，可以使用不定长参数。
（1） 位置传递
- 传进的所有参数都会被args变量收集，他会根据传进参数的位置合并为一个元组（tuple），args是元组类型，这就是位置传递
-
def user(*args): print(args) user('Belly',20,1) >>('Belly', 20, 1)
（2） 关键字传递
- 参数是键值对形式，所有键值对都会被kwargs接受，同时根据键值对组成字典
-
def user(**kwargs): print(kwargs) user(name = 'Belly',age = 20,sex = 1) >>{'name': 'Belly', 'age': 20, 'sex': 1}
（三） 匿名函数
1. 函数作为参数传递
- 函数本身可以作为参数，传入另一个函数中进行使用
- 函数传入的作用在于：传入计算逻辑，而非传入数据
2. lambda匿名函数
（1） 函数定义：
- def关键字：定义带有名称的函数（可以使用名称进行重复使用）
- lambda关键字：定义匿名函数（只可临时使用一次）
（2） lambda基本语法：
lambda 传入参数：函数体（一行代码）
！ 函数体只可写一行代码，无法写多行
-
def test(compute): result = compute(2,3) print(result) test(lambda x,y:x + y)
九、 Python文件操作
（一） 文件的编码
1. 编码
- 编码是一种规则集合，记录了内容和二进制间进行相互转换的逻辑
- 编码有许多种，最常用的是utf-8
2. 使用编码的原因
- 计算机只能识别二进制数，因此要将文件的内容翻译为二进制数，才能保存进计算机内
- 同时也需要编码，将计算机保存的二进制数，反向编译回可识别的内容
（二） 文件的读取
1. 文件的基本操作步骤
- 打开文件
- 读写文件
- 关闭文件
！ 可以只读，不写
2. 文件的基本操作函数
| 编号 | 关键字 | 使用方法 | 作用 |
| 1 | open | 文件对象 = open（file，mode，encoding） | 打开文件获得指定文件对象 |
| 2 | read | 文件对象.read（num） | 读取指定长度字节 不指定num读取文件全部 |
| 3 | readline | 文件对象.readline（） | 读取一行 |
| 4 | readlines | 文件对象.readline（） | 读取全部行，得到列表 |
| 5 | for | for line in 文件对象 | for循环文件行，一次循环得到一行数据 |
| 6 | close | 文件对象.close（） | 关闭文件对象 |
| 7 | with open | with open（） as f | 通过with open语法打开文件，可以自动关闭 |
！ 读取文件后，要用进行关闭，否则文件一直被占用
$练习：
-
word = open('D:\Desktop\word.txt', 'r', encoding="utf-8") L = word.readlines() num = 0 print(L) for i in L: num = num + i.count("itheima") print(num)
（三） 文件的写入
1. 写操作快速入门：
（1） 使用open的“w”模式进行写入
（2） 文件写入：f.write（）
（3） 内容刷新：f.flush（）
-
# 打开文件 f = open('D:\Desktop\word.txt','w') # 写入文件 f.write('hello world!') # 内容刷新 f.flush()
！ 直接调用write，内容并未真正写入文件，而是积攒在程序的内存中，称为缓冲区
！ 当调用flush时，文件才会真正写入文件
！ 这样避免频繁的操作硬盘，导致效率下降
2. 注意事项：
- w模式，文件不存在，会创建新文件
- w模式，文件存在，会清空原有内容
- close方法，具有flush方法的作用
（四） 文件的追加
1. 追加写入操作的快速入门
（1） 使用open的“a”模式进行写入
（2） 文件写入：f.write（）
（3） 内容刷新：f.flush（）
-
# 打开文件 f = open('D:\Desktop\word.txt','a') # 文件写入 f.write('I like pyhton!') # 内容刷新 f.flush()
2. 注意事项
- a模式，文件不存在，不会创建文件
- a模式，文件存在，会在最后追加写入文件
（五） 综合案例
"""
演示文件操作综合案例：文件备份
"""
# 打开文件得到文件对象，准备读取
fr = open("D:/bill.txt", "r", encoding="UTF-8")
# 打开文件得到文件对象，准备写入
fw = open("D:/bill.txt.bak", "w", encoding="UTF-8")
# for循环读取文件
for line in fr:
line = line.strip()
# 判断内容，将满足的内容写出
if line.split(",")[4] == "测试":
continue # continue进入下一次循环，这一次后面的内容就跳过了
# 将内容写出去
fw.write(line)
# 由于前面对内容进行了strip()的操作，所以要手动的写出换行符
fw.write("\n")
# close2个文件对象
fr.close()
fw.close() # 写出文件调用close()会自动flush()
十、 Pyhon异常、模块与包
（一） 了解异常
1. 异常
- 程序运行的过程中出现了错误
2. bug
- bug就是指异常的意思，因为历史是因为小虫子导致计算机失灵的案例，所以延续至今，bug就代表软件出现错误
（二） 异常的捕获方法
1. 程序出现bug后的情况
- 程序因为一个bug停止运行
- 对bug进行提醒·，整个程序继续运行
2. 为什么要捕获异常？
- 在可能发生异常的方法，进行捕获，当出现异常时，提供解决方式，而不是任由其导致程序无法运行
- 作用：提前假设某处会出现异常，做好提前准备，当真的出现异常的时候，可以有后续手段
（三） 异常综合案例
（四） Pyhton模块
（五） Python包
（六） 安装第三类Python包
十一、python综合基础案例——折线图可视化
十二、python综合基础案例——地图可视化
一、面向对象
（一）、初识对象
1.生活中数据的组织
学校开学，要求学生填写自己的基础信息，一人发一张白纸，让学生自己填
改为登记表，打印出来让学生自行填写：
2.程序中数据的组织
在程序中简单使用变量来记录学生信息
使用变量记录数据太乱了。
- 如果程序中也和生活中一样 可以设计表格
- 可以将设计的表格打印出来
- 可以将打印好的表格供人填写内容
那么数据的组织就非常方便了。
3.使用对象组织数据
在程序中是可以做到和生活中那样，设计表格、生产表格、填写表格的组织形式的。
- 在程序中设计表格，我们称之为：设计类（class）
-
class Student: name = None # 记录学生姓名
-
- 在程序中打印生产表格，我们称之为：创建对象
-
# 基于类创建对象 stu_1 = Student() stu_2 = Student()
-
- 在程序中填写表格，我们称之为：对象属性赋值
-
stu_1.name = "周杰伦" # 为学生1对象赋予名称属性值 stu_2.name = "张三" # 为学生2对象赋予名称属性值
4.总结：
-
1. 生活中或是程序中，我们都可以使用设计表格、生产表格、填写表格的形式组织数据
2. 进行对比，在程序中：
- 设计表格，称之为：设计类（class）
- 打印表格，称之为：创建对象
- 填写表格，称之为：对象属性赋值
（二）、类的成员和方法
1.类的定义和使用
我们简单了解到可以使用类去封装属性，并基于类创建出一个个的对象来使用。 现在我们来看看类的使用语法：
- class是关键字，表示要定义类了
- 类的属性，即定义在类中的变量（成员变量）
- 类的行为，即定义在类中的函数（成员方法）
创建类对象的语法：对象 = 类名称（）
2.成员变量和成员方法
什么是类的行为（方法）呢？
-
class Student: name = None # 学生的姓名 age = None # 学生的年龄 def say_hi(self): print(f"Hi大家好，我是{self.name}") stu = Student() stu.name = "张三" stu.age = 25 stu.say_hi() # Hi大家好，我是张三
可以看出，类中：
- 不仅可以定义属性用来记录数据
- 也可以定义函数，用来记录行为
其中：
- 类中定义的属性（变量），我们称之为：成员变量
- 类中定义的行为（函数），我们称之为：成员方法
定义在类内部的函数 称之为方法
3.成员方法的定义语法
在类中定义成员方法和定义函数基本一致，但仍有细微区别：
-
def 方法名(self, 形参1, ......, 形参N): 方法体
可以看到，在方法定义的参数列表中，有一个：self关键字
self关键字是成员方法定义的时候，必须填写的。
- 它用来表示类对象自身的意思
- 当我们使用类对象调用方法的是，self会自动被python传入
- 在方法内部，想要访问类的成员变量，必须使用self
-
def say_hi(self): print(f"Hi大家好，我是{self.name}")
-
4.注意事项
self关键字，尽管在参数列表中，但是传参的时候可以忽略它。 如：
-
class Student: name = None def say_hi(self): print("Hello 大家好") def say_hi2(self, msg): print(f"Hello 大家好，{msg}") stu = Student() stu.say_hi() # 调用的时候无需传参 stu.say_hi2("很高兴认识大家") # 调用的时候，需要传msg参数 结果： Hello 大家好 Hello 大家好，很高兴认识大家
可以看到，在传入参数的时候，self是透明的，可以不用理会它。
5.总结
类是由哪两部分组成呢？
- 类的属性，称之为：成员变量
- 类的行为，称之为：成员方法
注意：函数是写在类外的，定义在类内部，我们都称之为方法哦
类和成员方法的定义语法
- self的作用 表示类对象本身的意思
- 只有通过self，成员方法才能访问类的成员变量
- self出现在形参列表中，但是不占用参数位置，无需理会
（三）、类和对象
1.现实世界的事物和类
现实世界的事物也有属性和行为，类也有属性和行为。
使用程序中的类，可以完美的描述现实世界的事物
2.类和对象 对象名 = 类名称（）
基于类创建对象的语法:
为什么非要创建对象才能使用呢？
类只是一种程序内的“设计图纸”，需要基于图纸生产实体（对象），才能正常工作
这种套路，称之为：面向对象编程
3.使用类和对象描述现实事物
在现实中，生产事物
在程序中通过类来描述
4.基于类创建对象
-
class Clock: id = None # 序列号 price = None # 零售价 def ring(self): import winsound winsound.Beep(2000, 3000) clock1 = Clock() # 基于类创建对象 clock1.id = "003032" clock1.price = 100 print(f"闹铃ID：{clock1.id}，价格：{clock1.price}") clock1.ring() # 使用对象的属性和行为clock1 = Clock() clock2 = Clock() # 基于类创建对象 clock2.id = "003033" clock2.price = 152 print(f"闹铃ID：{clock2.id}，价格：{clock2.price}") clock2.ring() # 使用对象的属性和行为
5.总结：
1. 现实世界的事物由什么组成？
- 属性
- 行为
类也可以包含属性和行为，所以使用类描述现实世界事物是非常合适的
2. 类和对象的关系是什么？
- 类是程序中的“设计图纸”
- 对象是基于图纸生产的具体实体
3. 什么是面向对象编程？
- 面向对象编程就是，使用对象进行编程。
即，设计类，基于类创建对象，并使用对象来完成具体的工作
标签：name,Python,定义,笔记,学习,字符串,num,print,变量 From： https://blog.csdn.net/weixin_67870062/article/details/137233330