一、导学

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数据集合

  1. 字符串

！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              
   # 不限制宽度，小数点后四舍五入后为.35

 4）快速写法

语法：

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();

1. 使用：

使用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'>

1. 比较运算和比较运算符：

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

（二） 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 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，可以免费游玩
>> 祝您游玩愉快

$练习：

（五） 判断语句的嵌套

1. 基本格式

if 条件1 ：

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

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

……

  if条件2：

       满足条件2做的事情1

       满足条件2做的事情2

      ……

1. 嵌套的关键点：空格缩进

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

（六） 实战案例

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循环的基础案例

（三） 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!

1. 制表符/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循环的基础语法

1. 基础语法

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

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

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

1） 基本格式：

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

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

$练习：

1. range语句

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

2） 语法格式：

range（num）

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

range（num1，num2）

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

range（num1，num2，step）

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

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

$练习：

1. 变量作用域

（六）for循环的嵌套应用

1. 基本格式：

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

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

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

        ……

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

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

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

$练习：

（七） 循环中断：break和continue

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

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

（八） 综合案例

六、 Python函数

（一） 函数介绍

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

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

1. 函数好处：

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

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

（二） 函数定义

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.. 局部变量：定义在函数体内部的变量，只在函数体内部生效

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

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

2. 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（类）的成员，则称函数为方法。

编号关键字使用方法作用1index列表.index（元素）查找指定元素在列表中的下标，找不到则报错ValueError2lenlen（列表）统计容器中有多少元素3count列表.count（元素）统计此元素在列表中出现的次数4deldel 列表[下标]删除列表指定的下标元素5pop列表.pop[下标]删除列表指定的下标元素6remove列表.remove（元素）从前向后，删除此元素的第一个匹配项7append列表.append（元素）向列表中追加一个元素8extend列表.extend（容器）将数据容器中的内容依次取出，追加到列表尾部9insert列表.insert（下标，元素）在指定下标处，插入指定的元素10clear
列表.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. 元组的操作（方法）

编号关键字使用方法作用1indexindex（）查找指定数据在元组中的下标，找不到则报错2lenlen（元组）统计元组内有多少元素3countcount（）
统计某个数据在元组中出现的次数

！ 不可修改元组内容，否则直接报错

！ 可修改元组内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字符串[下标]根据下标索引取出特定位置字符2index字符串.index（字符串）查找给定字符的第一个匹配项的下标3replace字符串.replace（字符串1，字符串2）
将字符串内的全部字符串1，替换为字符串2

！不会改变原字符串，而是得到一个新的字符串
4split字符串.split（字符串）
按照给定字符串，对字符串进行分割

！不会改变原字符串，而是得到一个新的列表
5strip
字符串.strip（）

字符串.strip（字符串）
移除首尾的空格和换行符或指定字符串6
count
字符串.count（字符串）统计字符串内某字符串的出现次数7lenlen（字符串）统计字符串的字符个数

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. 集合的常用功能

编号关键字使用方法作用1add集合.add（元素）集合内添加一个元素2remove集合.remove（元素）移除集合内指定的元素3pop集合.pop（）从集合中随机取出一个元素4clear集合.clear（）将集合清空5difference集合1.difference（集合2）
得到一个新集合，内含2个集合的差集

原有的2个集合内容不变
6update集合1.difference_update（集合2）
在集合1中，删除集合2中存在的元素

集合1被修改，集合2不变
7union集合1.union（集合2）得到1个新集合，内含2个集合的全部元素原有的2个集合内容不变8lenlen（集合）得到一个整数，记录了集合的元素数量

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添加或更新键值对3pop字典.pop（Key）取出Key对应的Value并在字典内删除此Key的键值对4clear字典.clear（）清空字典5keys字典.keys（）获取字典的全部Key，可用于for循环遍历字典6lenlen（字典）计算字典内的元素数量

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的数据记录

（九） 数据容器的通用操作

序号功能描述1for循环遍历容器（字典是遍历key）2max（）容器内最大元素3min（）容器内最小元素4len（）容器内元素个数5list（）转换为列表6tuple（）转换为元组7str（）转换为字符串8set（）转换为集合9sorted（序列，[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. 文件的基本操作步骤

• 打开文件
• 读写文件
• 关闭文件

！ 可以只读，不写

1. 文件的基本操作函数
   编号关键字使用方法作用1open文件对象 = open（file，mode，encoding）打开文件获得指定文件对象2read文件对象.read（num）
   读取指定长度字节

不指定num读取文件全部
3readline文件对象.readline（）读取一行4readlines文件对象.readline（）读取全部行，得到列表5forfor line in 文件对象for循环文件行，一次循环得到一行数据6close文件对象.close（）关闭文件对象7with openwith 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时，文件才会真正写入文件

！ 这样避免频繁的操作硬盘，导致效率下降

1. 注意事项：

• 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()

1. 注意事项

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

（五） 综合案例

十、 Pyhon异常、模块与包

（一） 了解异常

1. 异常

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

2. bug

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

（二） 异常的捕获方法

1. 程序出现bug后的情况

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

2. 为什么要捕获异常？

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

（三） 异常综合案例

（四） Pyhton模块

（五） Python包

（六） 安装第三类Python包