2022黑马Python学习笔记

一、导学

  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中,字符串需要用双引号包围;

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

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

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 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

          ……

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

 

(三) 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("2022001t小王t99tt88tt0")
print("2022002t小周t92tt45tt93")
print("2022008t小黄t77tt82tt100")

(五) for循环的基础语法

1. 基础语法

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

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

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

1) 基本格式:

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

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

 $练习:

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       

$练习:

(七) 循环中断: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:Desktopword.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:Desktopword.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:Desktopword.txt','a')

# 文件写入
f.write('I like pyhton!')

# 内容刷新
f.flush()

2. 注意事项

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

(五) 综合案例

十、 Pyhon异常、模块与包

(一) 了解异常

1. 异常

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

2. bug

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

(二) 异常的捕获方法

1. 程序出现bug后的情况

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

2. 为什么要捕获异常?

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

(三) 异常综合案例

(四) Pyhton模块

(五) Python包

(六) 安装第三类Python包