一、导学

1. Pthon语言基础入门
2.  Pthon语言高阶加强
3. 大数据分析PySpark

二、 初识Python

1. 你好Python程序

print("Hello World!!")>>Hello World!!

！输入的双引号和括号为英文字符

三、 Python基础语法

（一） 字面量

      1. 定义：在代码中，被写下来的固定的值，称之为字面量。

      2. 常用的6种值的类型

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

     3. 字符串

！Python中，字符串需要用双引号包围；

！被双引号包围的都是字符串

66613.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 - 10print( "买了冰淇淋花费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 )>> >> >> 

        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 )>>  11>>  13.14

# 将字符串类型   ->  数字类型num = int( "11" )print( type( num ) , num )num2 = float( "13.14" )print( type( float ) , num2 )>>  11>>  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 )>>  11.0# 浮点数 -> 整数int_num = int( 13.14 )print( type( int_num ) , int_num )>>  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) )>> >> >> 

    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 = 11num2 = 11.345print( "数字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                 # 不限制宽度，小数点后四舍五入后为.35

     4）快速写法

语法：

f"内容{变量}"

name = "传智播客"set_up_year = 2006stock_price = 19.99print( 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中的类型是：

$练习：

（九）数据输入

语法

input();

使用：

使用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>> 你的银行卡密码的类型是： 

$练习： 

 四、 Python判断语句

（一） 布尔类型和比较运算符

布尔类型：判断结果

                    True：表示真（是、肯定）

                    False：表示假（否、否定）

# 定义变量存储布尔类型的数据bool_1 = Truebool_2 = Falseprint( f"bool_1变量的内容是：{ bool_1 }，类型为：{ type( bool_1 ) }" )print( f"bool_2变量的内容是：{ bool_2 }，类型为：{ type( bool_2 ) }" )>> bool_1变量的内容是：True，类型为：>> bool_2变量的内容是：False，类型为：

比较运算和比较运算符：

==、!=、>、<、>=、<=

（二） if语句的基本格式

if语句基本格式：

if 要判断的条件：

                 条件成立时，要做的事情

！首行缩进确定代码块归属

age = 30if age >= 18:    print( "我已经成年了。" )    print( f"已经{ age }岁了啊！" )print( "时间过得真快啊！" )>> 我已经成年了。>> 已经30岁了啊！>> 时间过得真快啊！

# 判断语句的结果必须为布尔类型的True或False

  True会执行if内的代码语句

  False则不会执行

age = 10if age >= 18:    print( "我已经成年了。" )    print( f"已经{ age }岁了啊！" )print( "时间过得真快啊！" )>> 时间过得真快啊！

 $练习： 

（三） if else 语句

基本格式：

if 条件 ：

    满足条件时要完成的事1

    满足条件时要完成的事2

……

else：

    不满足条件时要完成的事1

    不满足条件时要完成的事2

……

print( "欢迎来到黑马儿童游乐场，儿童免费，成人收费！" )age =  input( "请输入您的年龄：" )if int(age) >= 18 :    print( "您已成年，游玩需补票10元" )else :    print( "您未成年，无需补票" )print( "祝您游玩愉快！！！" )>> 欢迎来到黑马儿童游乐场，儿童免费，成人收费！>> 请输入您的年龄：17>> 您未成年，无需补票>> 祝您游玩愉快！！！

  $练习： 

（四） if elif else 语句

基本格式：

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 条件1 ：

    满足条件1时要完成的事1

    满足条件1时要完成的事2

……

      if条件2：

           满足条件2做的事情1

           满足条件2做的事情2

          ……

嵌套的关键点：空格缩进

   通过空格缩进，来决定语句之间的：层次关系

（六） 实战案例

import randomnum = 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循环的基本语法

  基本格式

while 条件：

      条件满足时，做的事情1

      条件满足时，做的事情2

     …（省略）…

• 只要条件满足，会无限循环执行
• 条件需要布尔类型结果

$练习：

 （二） while循环的基础案例

 

（三） while循环的嵌套应用

 1. 基本格式：

while 条件1：

      条件1满足时，做的事情1

      条件1满足时，做的事情2

     …（省略）…

      while 条件2：

          条件2满足时，做的事情1

          条件2满足时，做的事情2

          …（省略）…

（四） while循环的嵌套应用

补充：

print输出不换行

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

制表符/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")

（五） for循环的基础语法

基础语法

for循环就是将“待办事项”逐个完成的循环机制

• while循环的循环条件是自定义，自行控制循环条件
• for循环是一种“轮询”机制，是对一批内容进行逐个处理

！for循环无法定义循环条件，只能从被处理的数据集中，依次取出内容进行处理

1） 基本格式：

for 临时变量 in 待处理的数据集：

            循环满足条件时执行的语句

 $练习：

range语句

1） 功能：获得一个数字序列（可迭代类型的一种）

2） 语法格式：

range（num）

获取一个从0开始，到num结束的数字序列

range（num1，num2）

获取一个从num1开始，到num2结束的数字序列（不含num2本身）

range（num1，num2，step）

 获得一个从num1开始，到num2结束的数字序列（不含num2本身）

数字之间的步长，以step为准（step默认为1）

$练习：

变量作用域

（六）for循环的嵌套应用

基本格式：

for 临时变量 in 待处理的数据集：

            循环满足条件时执行的语句1

            循环满足条件时执行的语句2

            ……

             for 临时变量 in 待处理的数据集：

                          循环满足条件时执行的语句1

                          循环满足条件时执行的语句1       

$练习：

（七） 循环中断：break和continue

continue关键字作用：中断本次循环，直接进入下一次循环【for循环和while循环即可使用】

break关键字作用：所在循环永久中断【for循环和while循环即可使用】

（八） 综合案例

六、 Python函数

（一） 函数介绍

函数：是组织好的，可重复使用的，用来实现特定功能的代码段。

eg. len()：实现统计长度这一特定功能的代码段。

函数好处：

    * 将功能封装在函数内，可随时随地重复利用

    * 提高代码的复用性，减少重复代码，提高开发效率

（二） 函数定义

基本语法：

（1） 函数定义

def 函数名 （传入函数）：

        函数体

       return 返回值

（2） 函数调用

函数名（参数）

！参数可省略

！返回值可省略

！函数必须先定义后使用

$练习：

def printWelcome ():    print("欢迎来到黑马程序员！")    print("请出示48小时核酸检测证明！")printWelcome()

（三） 函数参数

传入参数的功能：在函数调用时，接受外部提供的数据

！参数之间按顺序传入；使用，进行分隔

$练习：

def printWelcome(x):    print("欢迎来到黑马程序员！请出示48小时核酸检测证明！")    if x <= 37.5:        print(f"体温测量中，您的体温是：{x}，体温正常，请进！")    else:        print(f"体温测量中，您的体温是{x}，需要隔离！")y = int(input("请输入您的体温："))printWelcome(y)

（四） 函数返回值

通过return关键字，可向调用者返回数据

. None类型：

（1） None，其类型是

（2） 无返回值的函数，实际上是返回了None这个字面量

（3） 使用：

• 用于函数返回值中【空】
• 用于if判断【None等同于False】
• 用于声明无内容的变量上

（五） 函数说明文档

函数说明文档：对函数进行说明解释，帮助更好地理解函数

. 定义语法：

def func（x，y）

     """

     函数说明

     ：param x：参数x的说明

     ：param x：参数x的说明

     ：return：返回值的说明

     """

     函数体

     return 返回值

（六） 函数嵌套使用

函数嵌套：在一个函数中，调用另一个函数。

执行流程：

函数a中执行到调用函数b的语句，会将b全部执行；完成后，继续执行函数a的剩余内容

（七） 变量的作用域

变量作用域：变量的作用范围

. 局部变量：定义在函数体内部的变量，只在函数体内部生效

    局部变量作用：在函数体内部，临时保存数据，即当函数调用完成后，销毁局部变量

全局变量：在函数体内外都能生效的变量

global关键字：可使函数内部声明变量为全局变量

（八） 综合案例

money = 5000000name = Nonedef 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数据容器

（一） 数据容器入门

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

. 种类：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 + 1print(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 = -9S1 = 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]["工资"] + 1000print(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和luckyn = int(input("请输入您所想的数字："))i = 1j = 0nums = list()lucky = list()print(n)while i <= n:    nums.append(i)    i = i + 1print(f"nums列表为：{nums}")for j in nums:    if j % 6 == 0:        lucky.append(j)    j = j + 1print(f"lucky列表为：{lucky}")

# 列表嵌套：# 3个教室[[],[],[]]# 8名讲师['A','B','C','D','E','F','G','H']# 随机分配import randomclassroom = [[],[],[]]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,2x,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	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 = 0print(L)for i in L:    num = num + i.count("itheima")print(num)

（三） 文件的写入

写操作快速入门：

（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） 使用open的“a”模式进行写入

（2） 文件写入：f.write（）

（3） 内容刷新：f.flush（）

# 打开文件f = open('D:\Desktop\word.txt','a')# 文件写入f.write('I like pyhton!')# 内容刷新f.flush()

注意事项

• a模式，文件不存在，不会创建文件
• a模式，文件存在，会在最后追加写入文件

（五） 综合案例

十、 Pyhon异常、模块与包

（一） 了解异常

1. 异常

• 程序运行的过程中出现了错误

2. bug

• bug就是指异常的意思，因为历史是因为小虫子导致计算机失灵的案例，所以延续至今，bug就代表软件出现错误

（二） 异常的捕获方法

1. 程序出现bug后的情况

• 程序因为一个bug停止运行
• 对bug进行提醒·，整个程序继续运行

2. 为什么要捕获异常？

• 在可能发生异常的方法，进行捕获，当出现异常时，提供解决方式，而不是任由其导致程序无法运行
• 作用：提前假设某处会出现异常，做好提前准备，当真的出现异常的时候，可以有后续手段

（三） 异常综合案例

（四） Pyhton模块

（五） Python包

（六） 安装第三类Python包

来源地址：https://blog.csdn.net/xuansoyo/article/details/127216665