Python基础——Python语言家族

在这里插入图片描述

一、Python语言家族

1 Introduction

1.1 Python 简介

Python 是一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言。

简单来说,Python是一门编程语言,帮助我们更好的与计算机沟通,功能全面、易学易用、可拓展语言,所以说,人生苦短,我学Python。

Python 的设计具有很强的可读性,相比其他语言经常使用英文关键字,其他语言的一些标点符号,它具有比其他语言更有特色语法结构。

  • Python 是一种解释型高级语言: 这意味着开发过程中没有了编译这个环节。类似于PHP和Perl语言。
  • Python 是交互式语言: 这意味着,您可以在一个Python提示符,直接互动执行写你的程序。
  • Python 是面向对象语言: 这意味着Python支持面向对象的风格或代码封装在对象的编程技术。
  • Python 是初学者的语言: Python 对初级程序员而言,是一种伟大的语言,开发代码量少,模块扩展库种类繁多,所以它支持广泛的应用程序开发,从简单的文字处理到 WWW 浏览器再到游戏。
扩展:编译型与解释型的原理
  • 编译型:编译器将源代码逐条编译成机器代码,任何一条语句 有错,都不能通过编译,最终形成目标代码,以后每次执行只执 行目标代码即可,因此执行速度快。
  • 解释型:解释器逐条解释源代码,成功一条就执行一 条,每次执行时都需要解释,所以速度稍慢

1.2 Python发展历史

  • Python的作者是荷兰人Guido von Rossum(龟叔)
  • 1982年,Guido从阿姆斯特丹大学(University of Amsterdam)获得了数学和计算机硕士学位。然而,尽管他算得上是一位数学家,但他更加享受计算机带来的乐趣。用他的话说,尽管拥有数学和计算机双料资质,他总趋向于做计算机相关的工作,并热衷于做任何和编程相关的活儿。
  • 1989年,为了打发圣诞节假期,Guido开始写Python语言的编译/解释器。Python来自Guido所挚爱的电视剧Monty Python’s Flying Circus (BBC1960-1970年代播放的室内情景幽默剧,以当时的英国生活为素材)。他希望这个新的叫做Python的语言,能实现他的理念(一种C和shell之间,功能全面,易学易用,可拓展的语言)。Guido作为一个语言设计爱好者,已经有过设计语言的(不很成功)的尝试。这一次,也不过是一次纯粹的hacking行为。
  • Python正式诞生于1991年
  • Python目前有两个版本,Python2和Python3,代码不完全兼容
  • 源文件.py文件猴后缀名
  • Python的解释器如今有多个语言实现,通常用的是Cpython或者IPython(官方版本的C语言实现),其他还有Jpython(Java平台)、IronPython(NET和Mono平台)、PyPy(Python实现)
扩展:Python2还是Python3
  • py2.7是2.x系列的最后一个版本,已经停止开发,不再增加新功能。2020年终止支持。所有的最新的标准库的更新改进,只会在3.x的版本里出现。Guido决定清理Python2.x ,并且不再兼容旧版本。
  • 最大的一个改变就是使用Unicode作为默认编码。Pyhton2.x中直接写中文会报错,Python3中可以直接写中文了。从开源项目看,支持py3的比例已经大大提高,知名的项目一般都支持py2.7和py3+。
  • py3比py2更规范统一、去掉了没必要的关键字Python3.x还在持续改进。
  • 所以我们还是推荐大家使用Python3.x。

2 Python的安装与使用

2.1 Python环境搭建

  • Python可应用于多平台包括Windows、 Linux/Unix 和 Mac OS。

  • Python有不同的搭建环境包括Python解释器(CPython)、编辑器(()IDLE,PyCharm,Sublime Text)、Python软件包管理系统(pip)

2.1.1 环境下载

2.1.2 Python编辑器

  • Ipython IDLE
  • Vim和macVim(linux,unix,macOSX)
  • Eclipse+pyDEV
  • Xcode(macOSX)
  • Notepad++(win)
  • Sublime Text(win,macOSX,linux,unix)
  • PyCharm(全平台)

2.1.3 Unix & Linux 平台安装 Python:(源码式安装)

  • 以下为在Unix & Linux 平台上安装 Python 的简单步骤:
    • 打开WEB浏览器访问http://www.python.org/download/
    • 选择适用于Unix/Linux的源码压缩包。
    • 下载及解压压缩包。
    • 如果你需要自定义一些选项修改Modules/Setup
    • 执行 ./configure 脚本
    • make
    • make install
  • 执行以上操作后,Python会安装在 /usr/local/bin 目录中,Python库安装在/usr/local/lib/pythonXX,XX为你使用的Python的版本号。

2.1.4 通过ubuntu官方的apt工具包安装

   $ sudo apt-get install python  
   $ sudo apt-get install python2.7  
   $ sudo apt-get install python3.7

2.1.5 Mac安装Python3

   $ brew sreach python
   $ brew install python3
   //在/usr/local/Cellar/这个目录下

2.1.6 windows下直接安装

① 首先访问http://www.python.org/download/ 下载最新环境

② 然后选择最新版本,并适用于自己系统的环境

③ 下载后,双击安装,选择“Install Now”默认安装,但一定勾选“Add Python 3.7 toPATH”

④ 如果没有添加环境,在安装之后,配置环境

3 Python的运行

运行Python的三种方式
  1. 交互式解释器

  2. 命令行运行Python源代码

  3. 使用编辑器或集成开发环境(IDE)例如:pycharm

3.1 交互式解释器

  • 你可以通过命令行窗口进入python并开在交互式解释器中开始编写Python代码。
  • 你可以在Unix,DOS或任何其他提供了命令行或者shell的系统进行python编码工作。
$ python # Unix/Linux 
或者 
C:>python # Windows/DOS
  • 以下为Python命令行参数:
选项描述
-d在解析时显示调试信息
-O生成优化代码 ( .pyo 文件 )
-S启动时不引入查找Python路径的位置
-V输出Python版本号
-X从 1.6版本之后基于内建的异常(仅仅用于字符串)已过时。
-c cmd执行 Python 脚本,并将运行结果作为 cmd 字符串。
file在给定的python文件执行python脚本。

3.2 命令行脚本

  • 在记事本中输入下列代码,另存为test.py文件
import requests
response=requests.get(https://img-bss.csdnimg.cn/201906261028104896.png)
pic = open('photo.jpg','wb')
pic.write(response.content)
  • 在你的应用程序中通过引入解释器可以在命令行中执行Python脚本,如下所示:
$ python test.py # Unix/Linux 
或者 
C:>python test.py # Windows/DOS

3.3 集成开发环境

  • PyCharm 是由 JetBrains 打造的一款 Python IDE,支持 macOS、 Windows、 Linux 系统。
  • PyCharm 功能 : 调试、语法高亮、Project管理、代码跳转、智能提示、自动完成、单元测试、版本控制……
  • PyCharm 下载地址 : https://www.jetbrains.com/pycharm/download/

3.3.1 Pycharm的基本使用

下载安装后,新建一个项目

选择Python解释器,并确定项目名称

新建一个Python源代码文件

给源文件起名字

运行源文件

得到运行结果

4 Python基础语法

4.1 Python注释

Python中的注释有单行注释和多行注释:

  • python中单行注释采用 # 开头。
#!/usr/bin/python
# -*- coding: UTF-8 -*-
# 文件名:test.py

# 第一个注释
print("Hello, Python!")  # 第二个注释

输出结果:

Hello, Python!

注释可以在语句或表达式行末:

name = "Madisetti" # 这是一个注释
  • python 中多行注释使用三个单引号(’’’)或三个双引号(""")。
#!/usr/bin/python
# -*- coding: UTF-8 -*-
# 文件名:test.py

'''
这是多行注释,使用单引号。
这是多行注释,使用单引号。
这是多行注释,使用单引号。
'''

"""
这是多行注释,使用双引号。
这是多行注释,使用双引号。
这是多行注释,使用双引号。
"""

4.2 Python语法格式-缩进

  • python最具特色的就是使用缩进来表示代码块,不需要使用大括号({})。
  • 缩进的空格数是可变的,但是同一个代码块的语句必须包含相同的缩进空格数。
  • 缩进强迫大家写出格式化的代码
  • 当语句以’:’结尾时,缩进的语句视为代码块
  • 约定俗成管理,4个空格为一个缩进
  • Python大小写敏感

实例如下:

if True:
    print ("True")
else:
    print ("False")
  • 以下代码最后一行语句缩进数的空格数不一致,会导致运行错误:
if True:
    print ("Answer")
    print ("True")
else:
    print ("Answer")
  print ("False")    # 缩进不一致,会导致运行错误
  • 以上程序由于缩进不一致,执行后会出现类似以下错误:
 File "test.py", line 6
    print ("False")    # 缩进不一致,会导致运行错误
                                      ^
IndentationError: unindent does not match any outer indentation level
多行语句
  • Python 通常是一行写完一条语句,但如果语句很长,我们可以使用反斜杠()来实现多行语句,例如:
total = item_one + \
        item_two + \
        item_three
  • 在 [], {}, 或 () 中的多行语句,不需要使用反斜杠(),例如:
total = ['item_one', 'item_two', 'item_three',
        'item_four', 'item_five']
空行
  • 函数之间或类的方法之间用空行分隔,表示一段新的代码的开始。类和函数入口之间也用一行空行分隔,以突出函数入口的开始。
  • 空行与代码缩进不同,空行并不是Python语法的一部分。书写时不插入空行,Python解释器运行也不会出错。但是空行的作用在于分隔两段不同功能或含义的代码,便于日后代码的维护或重构。
  • 记住:空行也是程序代码的一部分。

4.3 输入和输出:

input()输入:

  • input()的小括号中放入的是,提示信息,用来在获取数据之前给用户的一个简单提示
  • input()在从键盘获取了数据以后,会存放到等号右边的变量中
  • input()会把用户输入的任何值都作为字符串来对待
  • 注意:在python2中还有一个raw_input()输入,但到python3中没有了
#!/usr/bin/python3

str = input("请输入:");
print ("你输入的内容是: ", str)
  • 这会产生如下的对应着输入的结果:
请输入:Hello Python!
你输入的内容是:  Hello Python!

Print()输出:

  • print 默认输出是换行的,如果要实现不换行需要在变量末尾加上 end="":
#!/usr/bin/python3

x="a"
y="b"
# 换行输出
print( x )
print( y )

print('---------')
# 不换行输出
print( x, end=" " )
print( y, end=" " )
print()

# 同时输出多个变量
print(x,y)

format的格式化函数(了解)

  • 格式化字符串的函数 str.format(),它增强了字符串格式化的功能。
  • 基本语法是通过 {} 和 : 来代替以前的 % 。
>>>"{} {}".format("hello", "world")    # 不设置指定位置,按默认顺序
'hello world'

>>> "{0} {1}".format("hello", "world")  # 设置指定位置
'hello world'

>>> "{1} {0} {1}".format("hello", "world")  # 设置指定位置
'world hello world'

>>> print("网站名:{name}, 地址 {url}".format(name="百度", url="www.baidu.com")) #指定参数名
'网站名:百度, 地址 www.baidu.com'


>>>site = {"name": "百度", "url": "www.baidu.com"}
>>>print("网站名:{name}, 地址 {url}".format(**site)) # 通过字典设置参数
'网站名:百度, 地址 www.baidu.com' 

>>>my_list = ['百度', 'www.baidu.com']
>>>print("网站名:{0[0]}, 地址 {0[1]}".format(my_list))  # "0" 是必须的 通过列表索引设置参数
'网站名:百度, 地址 www.baidu.com'

>>> print("{:.2f}".format(3.1415926)); #数字格式化
3.14
数字格式输出描述
3.1415926{:.2f}3.14保留小数点后两位
3.1415926{:+.2f}+3.14带符号保留小数点后两位
-1{:+.2f}-1.00带符号保留小数点后两位
2.71828{:.0f}3不带小数
5{:0>2d}05数字补零 (填充左边, 宽度为2)
5{:x<4d}5xxx数字补x (填充右边, 宽度为4)
10{:x<4d}10xx数字补x (填充右边, 宽度为4)
1000000{:,}1,000,000以逗号分隔的数字格式
0.25{:.2%}25.00%百分比格式
1000000000{:.2e}1.00e+09指数记法
13{:10d}13右对齐 (默认, 宽度为10)
13{:<10d}13左对齐 (宽度为10)
13{:^10d}13中间对齐 (宽度为10)
11‘{:b}’.format(11) ‘{:d}’.format(11) ‘{: o}’.format(11) ‘{:x}’.format(11) ‘{:#x}’.format(11) ‘{:#X}’.format(11)1011 11 13 b 0xb 0XB进制

Python中的变量

  • Python 中的变量不需要声明。每个变量在使用前都必须赋值,变量赋值以后该变量才会被创建。
  • 在 Python 中,变量就是变量,它没有类型,我们所说的"类型"是变量所指的内存中对象的类型。
  • 等号(=)用来给变量赋值。
  • 等号(=)运算符左边是一个变量名,等号(=)运算符右边是存储在变量中的值。例如:
  • 实例(Python 3.0+)
#!/usr/bin/python3

counter = 100          # 整型变量
miles   = 1000.0       # 浮点型变量
name    = "demo"     # 字符串

print (counter)
print (miles)
print (name)
  • 执行以上程序会输出如下结果:
  100
  1000.0
  demo

多个变量赋值

  • Python允许你同时为多个变量赋值。例如:
a = b = c = 1
  • 以上实例,创建一个整型对象,值为1,三个变量被分配到相同的内存空间上。

  • 您也可以为多个对象指定多个变量。例如:

  a, b, c = 1, 2, "demo"
  • 以上实例,两个整型对象 1 和 2 的分配给变量 a 和 b,字符串对象 “demo” 分配给变量 c。

变量的命名

  • 在一个代码段内,尽量不要重名
  • 变量名由字母、数字、下划线组成,但不能以数字开头
  • Python 中的标识符是区分大小写
  • Python保留字: 保留字即关键字,我们不能把它们用作任何变量名称
  • 变量命名要符合PEP8规范,驼峰命名法

例如:
teacherName = 'yh'
stu_self = MiddleStudent( 'yh',20)

标识符

  • Python里,标识符: 由字母、数字、下划线组成,但不能以数字开头

  • Python 中的标识符是区分大小写的。

  • 特殊标识符:

    • 以下划线开头的标识符是有特殊意义的。以单下划线开头 _foo 的代表不能直接访问的类属性,需通过类提供的接口进行访问,不能用 from xxx import * 而导入;
    • 以双下划线开头的 __foo 代表类的私有成员;以双下划线开头和结尾的 __foo__ 代表 Python 里特殊方法专用的标识,如 __init__() 代表类的构造函数。
  • python保留字: 保留字即关键字,我们不能把它们用作任何标识符名称。Python 的标准库提供了一个 keyword 模块,可以输出当前版本的所有关键字:

  >>> import keyword
  >>> keyword.kwlist
  ['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 
  'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 
  'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'if',
  'return','try', 'while', 'with', 'yield']

5 数据类型

5.1 内置的基本数据类型

  • Python3中,只有一种整型类型int
  • 内置的type()函数可以查询变量所指的对象类型
  • 也可以使用内置的isinstance()函数来判断
  • Python3中True的值是1,False的值是0
  • 浮点只有单精度float,没有double双精度

5.2 Number 数字

  • Python3 支持 int、float、bool、complex(复数)。
  • 在Python 3里,只有一种整数类型 int,表示为长整型,没有 python2 中的 Long。
  • 像大多数语言一样,数值类型的赋值和计算都是很直观的。
  • 内置的 type() 函数可以用来查询变量所指的对象类型。
>>> a, b, c, d = 20, 5.5, True, 4+3j
>>> print(type(a), type(b), type(c), type(d))
<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>
  • 此外还可以用 isinstance 来判断:
>>>a = 111
>>> isinstance(a, int)
True
>>>
  • isinstance 和 type 的区别在于:
class A:
    pass

class B(A):
    pass

isinstance(A(), A)  # returns True
type(A()) == A      # returns True
isinstance(B(), A)    # returns True
type(B()) == A        # returns False
  • 区别就是:
    • type()不会认为子类是一种父类类型。
    • isinstance()会认为子类是一种父类类型。
注意:在 Python2 中是没有布尔型的,它用数字 0 表示 False,用 1 表示 True。
到 Python3 中,把 TrueFalse 定义成关键字了,但它们的值还是 10,它们可以和数字相加。
  • 当你指定一个值时,Number 对象就会被创建:
var1 = 1
var2 = 10
  • 您也可以使用del语句删除一些对象引用。
    • del语句的语法是:
    • del var1[,var2[,var3[…,varN]]]]
  • 您可以通过使用del语句删除单个或多个对象。例如
del var
del var_a, var_b
整数的进制:
# 输出其他进制数值

>>> bin(255) #255的二进制
'0b11111111'
>>> oct(255) #255的八进制
'0o377'
>>> hex(255) #255的十六进制
'0xff'

>>> a=0b10   #赋值二进制数值
>>> a
2
>>> a=0o10   #赋值八进制数值
>>> a
8
>>> a=0x10   #赋值十六进制数值
>>> a
16

5.2 字符串

  • Python中字符串三种标示

    • 使用单引号(’) str=‘this is string’
    • 使用双引号(") str=“this is string”
    • 使用三引号(’’’) str=’’‘this is string’’’
  • 字符串切片截取语法如下:

  • 变量[起始下标:结束下标:步进]

  • 反斜杠可以转义特殊字符

  • 常用字符串操作函数 len(),replace(),index(),find(),split()等

  • 加号 (+) 是字符串的连接符, 星号 (*) 表示复制当前字符串,紧跟的数字为复制的次数。实例如下:

#!/usr/bin/python3

str = 'zhangsan'

print (str)          # 输出字符串
print (str[0:-1])    # 输出第一个到倒数第二个的所有字符
print (str[0])       # 输出字符串第一个字符
print (str[2:5])     # 输出从第三个开始到第五个的字符
print (str[2:])      # 输出从第三个开始的后的所有字符
print (str * 2)      # 输出字符串两次
print (str + "TEST") # 连接字符串
  • Python 使用反斜杠()转义特殊字符,如果你不想让反斜杠发生转义,可以在字符串前面添加一个r,表示原始字符串:
>>> print('Ru\noob')
Ru
oob
>>> print(r'Ru\noob')
Ru\noob
>>>
  • 另外,反斜杠()可以作为续行符,表示下一行是上一行的延续。也可以使用 “”"…""" 或者 ‘’’…’’’ 跨越多行。
  • 注意,Python 没有单独的字符类型,一个字符就是长度为1的字符串。
>>>word = 'Python'
>>> print(word[0], word[5])
P n
>>> print(word[-1], word[-6])
n P
  • 与 C 字符串不同的是,Python 字符串不能被改变。向一个索引位置赋值,比如word[0] = 'm’会导致错误。
  • 注意:
    • 反斜杠可以用来转义,使用r可以让反斜杠不发生转义。
    • 字符串可以用+运算符连接在一起,用*运算符重复。
    • Python中的字符串有两种索引方式,从左往右以0开始,从右往左以-1开始。
    • Python中的字符串不能改变。

5.3 列表

  • List(列表)是一种有序集合,可以随时添加和删除其中元素

  • 列表的元素可以不同

  • 列表同样支持切片截取语法如下:

    • 变量[起始下标:结束下标:步进]
  • 列表格式[“yh”,“micheal”,“jack”],[]之间,元素逗号隔开

  • 索引值从0开始,-1代表末尾

  • 使用(+)可以连接两个列表,(*)是重复操作

  #!/usr/bin/python3
  
  list = [ 'abcd', 786 , 2.23, 'demo', 70.2 ]
  tinylist = [123, 'demo']
  
  print (list)            # 输出完整列表
  print (list[0])         # 输出列表第一个元素
  print (list[1:3])       # 从第二个开始输出到第三个元素
  print (list[2:])        # 输出从第三个元素开始的所有元素
  print (tinylist * 2)    # 输出两次列表
  print (list + tinylist) # 连接列表
  • 以上实例输出结果:

    ['abcd', 786, 2.23, 'demo', 70.2]
    abcd
    [786, 2.23]
    [2.23, 'demo', 70.2]
    [123, 'demo', 123, 'demo']
    ['abcd', 786, 2.23, 'demo', 70.2, 123, 'demo']
    
  • 与Python字符串不一样的是,列表中的元素是可以改变的:

  >>> a = [1, 2, 3, 4, 5, 6]
  >>> a[0] = 9
  >>> a[2:5] = [13, 14, 15]
  >>> a
  [9, 2, 13, 14, 15, 6]
  >>> a[2:5] = []   # 将对应的元素值设置为 [] 
  >>> a
  [9, 2, 6]
  • List内置了有很多方法,例如append()、pop()等

  • 注意

    • List写在方括号之间,元素用逗号隔开。
    • 和字符串一样,list可以被索引和切片。
    • List可以使用+操作符进行拼接。
    • List中的元素是可以改变的。

5.4 元组

  • Tuple(元组)与列表类似,不同之处在于元组的元素不能修改
  • 元组写在小括号()里,元素之 间用逗号隔开
  • 元组中元素类型也可以不同
  • 列表同样支持切片
  • 索引值从0开始,-1代表末尾
  • 如果元组中的元素只有一个,那么写成(1,),不要写成(1)
#!/usr/bin/python3

tuple = ( 'abcd', 786 , 2.23, 'demo', 70.2  )
tinytuple = (123, 'demo')

print (tuple)             # 输出完整元组
print (tuple[0])          # 输出元组的第一个元素
print (tuple[1:3])        # 输出从第二个元素开始到第三个元素
print (tuple[2:])         # 输出从第三个元素开始的所有元素
print (tinytuple * 2)     # 输出两次元组
print (tuple + tinytuple) # 连接元组
  • 以上实例输出结果:
  ('abcd', 786, 2.23, 'demo', 70.2)
  abcd
  (786, 2.23)
  (2.23, 'demo', 70.2)
  (123, 'demo', 123, 'demo')
  ('abcd', 786, 2.23, 'demo', 70.2, 123, 'demo')
  • 元组与字符串类似,可以被索引且下标索引从0开始,-1 为从末尾开始的位置。

  • 也可以进行截取(看上面,这里不再赘述)。

  • 其实,可以把字符串看作一种特殊的元组。

>>>tup = (1, 2, 3, 4, 5, 6)
>>> print(tup[0])
1
>>> print(tup[1:5])
(2, 3, 4, 5)
>>> tup[0] = 11  # 修改元组元素的操作是非法的
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>>
  • 虽然tuple的元素不可改变,但它可以包含可变的对象,比如list列表。
  • 构造包含 0 个或 1 个元素的元组比较特殊,所以有一些额外的语法规则:
tup1 = ()    # 空元组
tup2 = (20,) # 一个元素,需要在元素后添加逗号
string、listtuple都属于sequence(序列)。
  • 注意:
    • 与字符串一样,元组的元素不能修改。
    • 元组也可以被索引和切片,方法一样。
    • 注意构造包含0或1个元素的元组的特殊语法规则。
    • 元组也可以使用+操作符进行拼接。

5.5 集合

  • Set(集合),是一个无序不重复元素的序列

  • 可以使用大括号 { } 或者set()函数创建集合

    • 注意:创建一个空集合必须用set()而不是 { },因为 { } 是用来创建一个空字典
  • 创建格式:

    • {value1, value2, value3, value4,….} 或者 set(value)
  • 集合之间可以进行:-差集 &交集 |并集 ^反交集

  # set可以进行集合运算
  a = set('abracadabra')
  b = set('alacazam')
  print(a)
  
  print(a - b)     # a和b的差集
  print(a | b)     # a和b的并集
  print(a & b)     # a和b的交集
  print(a ^ b)     # a和b中不同时存在的元素
  • 以上实例输出结果:
  {'Mary', 'Jim', 'Rose', 'Jack', 'Tom'}
  Rose 在集合中
  {'b', 'a', 'c', 'r', 'd'}
  {'b', 'd', 'r'}
  {'l', 'r', 'a', 'c', 'z', 'm', 'b', 'd'}
  {'a', 'c'}
  {'l', 'r', 'z', 'm', 'b', 'd'}

5.6 字典

  • 字典(dictionary)是无序集合对象,元素是通过key-value键值对来存取的

  • 字典是一种映射类型,字典用"{ }"标识,它是一个无序的键(key) : 值(value) 对集合

  • 键(key)必须使用不可变类型、在同一个字典中,键(key)必须是唯一的

  • 另外,字典类型也有一些内置的函数,例如clear()、keys()、values()等。

  • 字典方便我们使用查找和搜索功能

#!/usr/bin/python3

dict = {}
dict['one'] = "1 - Python教程"
dict[2] = "2 - Python工具"

tinydict = {'name': 'demo','code':1, 'site': 'www.demo.com'}


print (dict['one'])       # 输出键为 'one' 的值
print (dict[2])           # 输出键为 2 的值
print (tinydict)          # 输出完整的字典
print (tinydict.keys())   # 输出所有键
print (tinydict.values()) # 输出所有值

以上实例输出结果:

1 - Python教程
2 - Python工具
{'name': 'demo', 'site': 'www.demo.com', 'code': 1}
dict_keys(['name', 'site', 'code'])
dict_values(['demo', 'www.demo.com', 1])
  • 构造函数 dict() 可以直接从键值对序列中构建字典如下:
  • 实例
>>>dict([('demo', 1), ('Google', 2), ('Taobao', 3)])
{'Taobao': 3, 'demo': 1, 'Google': 2}

>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}

>>> dict(demo=1, Google=2, Taobao=3)
{'Taobao': 3, 'demo': 1, 'Google': 2}
  • 另外,字典类型也有一些内置的函数,例如clear()、keys()、values()等。
  • 注意:
    • 1、字典是一种映射类型,它的元素是键值对。
    • 2、字典的关键字必须为不可变类型,且不能重复。
    • 3、创建空字典使用 { }。

5.7 数据类型转换【扩展内容】

  • 有时候,我们需要对数据内置的类型进行转换,数据类型的转换,你只需要将数据类型作为函数名即可。
  • 以下几个内置的函数可以执行数据类型之间的转换。这些函数返回一个新的对象,表示转换的值
函数描述
int(x [,base])将x转换为一个整数
float(x)将x转换到一个浮点数
complex(real [,imag])创建一个复数
str(x)将对象 x 转换为字符串
repr(x)将对象 x 转换为表达式字符串
eval(str)用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s)将序列 s 转换为一个元组
list(s)将序列 s 转换为一个列表
set(s)转换为可变集合
dict(d)创建一个字典。d 必须是一个序列 (key,value)元组。
frozenset(s)转换为不可变集合
chr(x)将一个整数转换为一个字符
unichr(x)将一个整数转换为Unicode字符
ord(x)将一个字符转换为它的整数值
hex(x)将一个整数转换为一个十六进制字符串
oct(x)将一个整数转换为一个八进制字符串
数据类型转换分类:
  • 数据类型转换一共分为2类:自动数据类型转换(隐式转换)和强制数据类型转换(显示转换)
自动数据类型转换/隐式转换
  • 自动类型转换是程序根据运算要求进行的转换,不需要人工干预 1.自动类型转换不需要人工干预 2.自动类型转换多发生在运算或者判断过程中 3.转化时向着更加精确的类型转换
强制类型转换/显示转换
  • 根据程序需要,由编写程序人员人为改变数据类型的方式就是强制数据类型转换。
  • int() 将其他类型转化为整型
1.数字整型转化之后,还是原来的味道
2.浮点类型转化之后,舍去小数部分
3.布尔值转化之后 True -> 1 False->0
4.字符串转换,仅纯整型字符串可以转化(浮点型或者带有其他字符都不可以转化)
5.复数不可以转换
  • float() 将其他类型转化为浮点型
1.整型转换之后变为浮点型,后面+.0
2.浮点数不需要转化,转化也不会变化
3.布尔值转化 True->1.0  False ->0.0
4.字符串,纯整型字符串和纯浮点型字符串可以转换,其他都不可以
  • complex() 将其他数据转化为复数
1.整型转换之后变为 (整型+0j2.浮点型转换之后变为(浮点型 + 0j)
3.布尔值转化之后 True->1+0jFalse(0j)
4.字符串,纯整型和浮点型字符串可以转化,其他都不行
5.复数,无需转换
  • bool() 将其他类型转化为布尔值
#下面转化为布尔值false的情况
    1.整型   0
    2.浮点型  0.0
    3.复数  0+0j
    4.布尔  False
    5.字符串  '' 空字符串
    6.列表   [] 空列表
    7.元组   ()空元组
    8.字典   {} 空字典
    9.集合   set() 空集合
  • str() 将其他类型转化为字符串
    • 所有转换均改变类型为字符串,表示方式依旧不变
  • list() 将其他类型转化为列表类型
    • 在python中有5中可迭代序列,可以互相转换,他们分别是:
    • 字符串,列表,元组,字典,集合
var = ('张三','李四','王老五')

newvar = list(var)

newvar的值为 ['张三','李四','王老五']
  • 注意:
    • 1.字符串转换时每个字符变成列表中的一个值
    • 2.字典类型转换时,仅将字典的键部分转换成列表,忽略值部分
  • tuple() 将其他类型转化为元组类型
var = {'张三','李四','王老五'}

newvar = tuple(var)

newvar的值为 ('张三','李四','王老五')
  • 注意:

    • 1.字符串转换时每个字符变成元组中的一个值
    • 2.字典类型转换时,仅将字典的键部分转换成元组,忽略值部分
  • set() 将其他类型转化为集合类型

var = ['张三','李四','王老五']
newvar = set(var)
newvar的值为 {'张三','李四','王老五'}  #值的顺序不定
  • 注意:

    • 1.字符串转换时每个字符变成集合中的一个值
    • 2.字典类型转换时,仅将字典的键部分转换集合,忽略值部分
  • dict() 将其他类型转换为字典类型

  • 其他类型转化为字典时需要按照指定的格式才可以转化:(列表和元组的组合可以)

[['cat', '黑猫警长'], ['mouse', '一只耳'], ['next', '请看夏季']]
[('cat', '黑猫警长'),'mouse', '一只耳','next', '请看夏季']

6 分支结构

  • 流程: 计算机执行代码的顺序就是流程
  • 流程控制: 对计算机代码执行顺序的管理就是流程控制 流程分类:
  • 流程控制一共分为三类:
    • 顺序结构
    • 分支结构/选择结构
    • 循环结构
  • 分支结构一共分为4类:
    • 单项分支
    • 双项分支
    • 多项分支
    • 巢状分支

6.1 单项分支

'''
if <条件判断1>:
	 <执行1>
'''
# 例子
age = 30
if age >= 18:
	print('your age is', age) 
	print('adult')
  • 特征:
    • if条件表达式结果为真,则执行if之后所控制代码组,如果为假,则不执行后面的代码组(:后面的N行中有相同缩进的代码)
    • :之后下一行的内容必须缩进,否则语法错误!
    • if之后的代码中如果缩进不一致,则不会if条件表达式是的控制,也不是单项分支的内容,是顺序结构的一部分
    • if:后面的代码是在条件表达式结果为真的情况下执行,所以称之为真区间或者if区间、

6.2 双项分支

'''
if <条件判断1>:
	 <执行1>
else:
	<执行2>
'''
# 例子
age = 13
if age >= 16:
	print('your age is', age)
	print('adult')
else:
	print('your age is', age)
	print('teenager')
  • 特征:
    • 1.双项分支有2个区间:分别是True控制的if区间和False控制的else区间(假区间)
    • 2.if区间的内容在双项分支中必须都缩进,否则语法错误!

6.3 多项分支

'''
if <条件判断1>:
	 <执行1>
elif <条件判断2>: 
	<执行2>
elif <条件判断3>:
	 <执行3>
else:
	<执行4>
'''
# 例子
age = 20
if age >= 6:
	print('teenager')
elif age >= 18:
	print('adult')
else:
	print('kid')
  • 特征:
    • 1.多项分支可以添加无限个elif分支,无论如何只会执行一个分支
    • 2.执行完一个分支后,分支结构就会结束,后面的分支都不会判断也不会执行
    • 3.多项分支的判断顺序是自上而下逐个分支进行判断
    • 4.在Python中没有switch – case语句。
  • 实例-演示了狗的年龄计算判断:
#!/usr/bin/python3

age = int(input("请输入你家狗狗的年龄: "))
print("")
if age < 0:
    print("你是在逗我吧!")
elif age == 1:
    print("相当于 14 岁的人。")
elif age == 2:
    print("相当于 22 岁的人。")
elif age > 2:
    human = 22 + (age -2)*5
    print("对应人类年龄: ", human)
### 退出提示
input("点击 enter 键退出")

6.4 巢状分支【*扩展内容】

  • 巢状分支是其他分支结构的嵌套结构,无论哪个分支都可以嵌套
# !/usr/bin/python3

num=int(input("输入一个数字:"))
if num%2==0:
    if num%3==0:
        print ("你输入的数字可以整除 2 和 3")
    else:
        print ("你输入的数字可以整除 2,但不能整除 3")
else:
    if num%3==0:
        print ("你输入的数字可以整除 3,但不能整除 2")
    else:
        print  ("你输入的数字不能整除 2 和 3")
  • 上述程序,执行后输出结果为:
输入一个数字:6
你输入的数字可以整除 23

7 循环结构

  • 循环是让计算机做重复任务的有效方法
  • 循环结构分为2类:while循环 和 for..in循环

7.1 break语句与continue语句

  • break作用:在循环中break的作用是终止当前循环结构的后续操作,一旦程序运行了break,循环也就终止了!

  • break 语句可以跳出 for 和 while 的循环体。如果你从 for 或 while 循环中终止,任何对应的循环 else 块将不执行。 实例如下

  • continue语句被用来告诉Python跳过当前循环块中的剩余语句,然后继续进行下一轮循环。

7.2 while循环和break

# 1到100求和
n = 1
while n <= 100:
	if n > 10: # 当n = 11时,条件满足,执行break语句
		break # break语句会结束当前循环
	print(n)
	n = n + 1
print('END')
  • while循环,只要条件满足,就不断循环,条件不满足时退出循环
  • 在循环中,break语句可以提前退出循环
注意:死循环就是循环不会终止的循环类型

7.3 while循环和continue

n = 0
while n < 10:
	n = n + 1
	if n % 2 == 0: # 如果n是偶数,执行continue语句
		continue # continue语句会直接继续下一轮循环,后续的print()语句不会执行
	print(n)
  • 在循环过程中,也可以通过continue语句,跳过当前的这次循环,直接开始下一次循环
  • 执行上面的代码可以看到,打印的不再是1~10,而是1,3,5,7,9

7.4 for…in循环

# 1到10求和
sum = 0
for x in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]:
	sum = sum + x
print(sum)

# 遍历list
names = [’小红‘, ’小军‘, ’小明']
for name in names:
	print(name)forin 循环用

在for…in 循环用于遍历容器类的数据(字符串,列表,元组,字典,集合)

7.5 range()函数

如果你需要遍历数字序列,可以使用内置range()函数。它会生成数列,例如:

for i in range(5): # 遍历出0~4的值
	print(i)
for i in range(5,9): # 遍历出5~8的值
	print(i)
for i in range(0,10,3): # 遍历出0,3,6,9的值
	print(i)
for i in range(5-10,-100,-30): # 遍历出-10,-40,-70的值
	print(i) 
a = ['Google', 'Baidu', 'Sina', 'Taobao', 'QQ']
for i in range(len(a)): #遍历列表
	print(i, a[i])

7.6 pass 语句 【扩展内容】

  • Python pass是空语句,是为了保持程序结构的完整性。
  • pass 不做任何事情,一般用做占位语句,如下实例

8 函数

  • 函数的本质就是功能的封装。使用函数可以大大提高编程效率与程序的可读性。
  • 函数是能够实现特定功能的计算机代码而已,他是一种特定的代码组结构。
  • 函数的作用
    • 1.提升代码的重复利用率,避免重复开发相同代码
    • 2.提高程序开发效率
    • 3.便于程序维护

8.1 函数的定制

  • 函数代码块以 def 关键词开头,后接函数标识符名称和圆括号 ()。
  • 任何传入参数和自变量必须放在圆括号中间,圆括号之间可以用于定义参数。
  • 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
  • 函数内容以冒号起始,并且缩进。
  • return [表达式] 结束函数,选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

8.2 函数的命名

函数名的命名规则:和变量基本一样

  • 1.推荐使用英文或者拼音,禁止使用中文
  • 2.可以使用数字,但是不能用数字开头
  • 3.不可以使用特殊字符,除了_
  • 4.函数名严格区分大小写
  • 5.函数名必须要有意义。
  • 6.不能和系统已经存在的保留关键字冲突!
  • 7.禁止使用和系统提供函数相同的函数名

8.3 带有参数的函数格式

def 函数名(参数,参数….): 
	函数功能代码...
	函数功能代码... 
	return(没有return 默认返回None)
调用函数: 函数名(参数,参数….)
  • 形参: 形式上的参数,声明函数时()中的参数是形参
  • 实参: 实际上的参数,调用函数时()中的参数是实参
  • 注意: 实参将值传递给形参的过程本质上就是简单的变量赋值仅此而已
  • 参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样

形参: 形式上的参数,声明函数时()中的参数是形参
实参: 实际上的参数,调用函数时()中的参数是实参
注意: 实参将值传递给形参的过程本质上就是简单的变量赋值仅此而已
参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样

8.3.1 函数参数格式

  1. 默认值的参数:可选择性输入的参数
  2. 可变参数 :可以输入0到任意个参数,函数内组装成tuple
  3. 关键字参数:可以输入0到任意个含参数名参数,函数内组装成一个dict
  4. 命名关键字参数
  5. 多种参数混合:顺序是必选,默认,可变,命名关键字,关键字

8.4 函数返回值

  • 调函数根据执行完毕是否可以得到一个结果,将函数分为2个类型:
    • 执行过程函数: print()
    • 具有返回值的函数:id(),type()
  • return的特征:
    • 具有return语句的函数称为具有返回值的函数
    • return可以为当前函数执行完毕返回一个结果,这样的函数调用可以被接受
    • return执行之后,函数则会终止,所有return之后的语句不会被执行
    • 一个函数可以书写多个return语句,但是一般会放入分支结构当中
    • 一个函数若要返回多个数据,可借助复合数据类型(list,tuple,set,dict) 来操作即可!
    • 不带参数值的return语句返回None

8.5 函数文档

  • 函数文档就是用来查看当前函数相关信息介绍的一个特定格式而已
  • 查看函数文档的方法:
    • help(函数名称) # 直接输出显示函数文档的内容字符串
    • 函数名.doc # 直接输出显示函数文档的内容元字符串(转义字符不转义)
    • 官方文档 http://docs.python.org/3/library/functions.html
def 函数名(参数...): 
	'''
	在此处声明函数文档
	''' 
	函数功能代码... 
  • 注意:函数文档的作用是对函数进行说明,便于阅读和快速掌握函数的使用,通常函数文档需要具有以下信息:
    • 函数的作用
    • 函数的参数介绍(个数,数据类型)
    • 函数的返回值(数据和类型)

8.6 局部变量和全局变量

  • 定义在函数内部的变量拥有一个局部作用域,定义在函数外的拥有全局作用域。
  • 局部变量只能在其被声明的函数内部访问,而全局变量可以在整个程序范围内访问。调用函数时,所有在函数内声明的变量名称都将被加入到作用域中。如下实例:
#!/usr/bin/python3

total = 0; # 这是一个全局变量
# 可写函数说明
def sum( arg1, arg2 ):
    #返回2个参数的和."
    total = arg1 + arg2; # total在这里是局部变量.
    print ("函数内是局部变量 : ", total)
    return total;

#调用sum函数
sum( 10, 20 );
print ("函数外是全局变量 : ", total)
  • 以上实例输出结果:
函数内是局部变量 :  30
函数外是全局变量 :  0

8.7 匿名函数【扩展内容】

  • python 使用 lambda 来创建匿名函数。
  • 所谓匿名,意即不再使用 def 语句这样标准的形式定义一个函数。
  • lambda 只是一个表达式,函数体比 def 简单很多。
  • lambda的主体是一个表达式,而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
  • lambda 函数拥有自己的命名空间,且不能访问自己参数列表之外或全局命名空间里的参数。
  • 虽然lambda函数看起来只能写一行,却不等同于C或C++的内联函数,后者的目的是调用小函数时不占用栈内存从而增加运行效率。
  • 语法:
  • lambda 函数的语法只包含一个语句,如下:
lambda [arg1 [,arg2,.....argn]]:expression
  • 如下实例:
#!/usr/bin/python3

# 可写函数说明
sum = lambda arg1, arg2: arg1 + arg2;

# 调用sum函数
print ("相加后的值为 : ", sum( 10, 20 ))
print ("相加后的值为 : ", sum( 20, 20 ))
  • 以上实例输出结果:
相加后的值为 :  30
相加后的值为 :  40

9 文件读写

9.1 Python 内置的文件读写操作

  • open() 打开或者创建一个文件
    格式:open('文件路径','打开模式')
    返回值:文件io对象
    打开模式一共N种:
        w模式 写模式write  文件不存在时会创建文件,如果文件已存在则会清空文件
        r模式  读模式read  文件不存在就报错,存在则准备读取文件
        a模式 追加模式 append 文件不存在则新建,文件存在则在文件末尾追加内容
        x模式 抑或模式 xor 文件存在则报错,文件 不存在则新建文件
        b模式 二进制模式 binary 辅助模式不能单独使用
        +模式 增强模式plus  也是辅助模式不能单独使用
  • 以上模式可以互相组合:wrax不可以互相组合:
模式说明
r以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
w打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在,创建新文件。
a打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。也就是说,新的内容将会被写入到已有内容之后。如果该文件不存在,创建新文件进行写入。
rb以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。
wb以二进制格式打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在,创建新文件。
ab以二进制格式打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。也就是说,新的内容将会被写入到已有内容之后。如果该文件不存在,创建新文件进行写入。
r+打开一个文件用于读写。文件指针将会放在文件的开头。
w+打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在,创建新文件。
a+打开一个文件用于读写。如果该文件已存在,文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在,创建新文件用于读写。
rb+以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
wb+以二进制格式打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在,创建新文件。
ab+以二进制格式打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。如果该文件不存在,创建新文件用于读写
  • close() 关闭文件

9.2 读写函数:

  • read() 读取文件
'''
格式:文件io对象.read()
返回值:整个文件的字符

格式:文件io对象.read(字符长度)
返回值:指定长度的字符
'''
f = open('test.txt', 'r')
content = f.read(5)
print(content)
print("-"*30)
content = f.read()
print(content)
f.close()
  • readline() 读取一行文件
'''
格式:文件io对象.readline()
返回值:一行内容的字符串

格式:文件io对象.readline(字符长度)
返回值:一行内容的字符串

注意:字符长度<当前行内内容,则读取指定长度的字符串,并且下次再读取还是在
这个一行中获取没有读取的内容。字符长度>=当前行内容,直接读取当前行
'''
#coding=utf-8

f = open('test.txt', 'r')
content = f.readline()
print("1:%s"%content)
content = f.readline()
print("2:%s"%content)
f.close()
  • readlines() 将文件中的内容读取到序列当中。
'''
格式:文件io对象.readlines()
返回值:列表

格式:文件io对象.readlines(字符长度)
返回值:列表

注意:读取的行数由字符长度决定,如果字符长度读取了N行后,还有指定长度的字符
     没有读取,则直接读取下一行进来
'''
#coding=utf-8

f = open('test.txt', 'r')
content = f.readlines()
print(type(content))
i=1
for temp in content:
    print("%d:%s"%(i, temp))
    i+=1
f.close()
  • write() 写入文件
格式:文件io对象.write(字符串)
返回值:写入字符串的长度
  • writelines() 将序列写入文件中
格式:文件io对象.writelines(序列)
返回值:None
  • truncate() 字符串截取操作
格式:文件io对象.truncate(字节长度)
返回值:截取的字节长度

9.3 OS模块

  • OS – 操作系统的简称
  • os模块就是对操作系统进行操作
  • 使用该模块必须先导入模块:
import os
os模块中的函数:
序号函数名称描述格式
1getcwd()获取当前的工作目录格式:os.getcwd() 返回值:路径字符串
2chdir()修改当前工作目录格式:os.chdir() 返回值:None
3listdir()获取指定文件夹中的 所有文件和文件夹组成的列表格式:os.listdir(目录路径) 返回值:目录中内容名称的列表
4mkdir()创建一个目录/文件夹格式:os.mkdir(目录路径) 返回值:None
5makedirs()递归创建文件夹格式:os.makedirs(路径)
6rmdir()移除一个目录(必须是空目录)格式:os.rmdir(目录路径) 返回值:None
7removedirs()递归删除文件夹格式:os.removedirs(目录路径) 返回值:None 注意最底层目录必须为空
8rename()修改文件和文件夹的名称格式:os.rename(源文件或文件夹,目标文件或文件夹) 返回值:None
9stat()获取文件的相关 信息格式:os.stat(文件路径) 返回值:包含文件信息的元组
10system()执行系统命令格式:os.system() 返回值:整型 慎用! 玩意来个rm -rf 你就爽了!
11getenv()获取系统环境变量格式:os.getenv(获取的环境变量名称) 返回值:字符串
12putenv()设置系统环境变量格式:os.putenv(‘环境变量名称’,值) 返回值:无 注意:无法正常的getenv检测到。
13exit()推出当前执行命令,直接关闭当前操作格式:exit() 返回值:无

当前os模块的值:

序号函数名称描述
1curdiros.curdir 获取当前路径 都是.
2pardiros.pardir 获取上层目录路径 都是…
3pathos.path os中的一个子模块,操作非常多
4nameos.name 当前系统的内核名称 win->nt linux/unix->posix
5sepos.sep 获取当前系统的路径分割符号 window -> \ linux/unix -> /
6extsepos.extsep 获取当前系统中文件名和后缀之间的分割符号,所有系统都是.
7linesepos.linesep 获取当前系统的换行符号 window -> \r\n linux/unix -> \n
os.environ模块
  • os.environ 可以直接获取所有环境变量的信息组成的字典,如果希望更改环境变量,并且可以查询得到,就需要对os.environ进行操作
  • 该模块的所有方法均是字典的方法,可以通过字典的os.environ的结果进行操作。
  • 注意:无论使用os.getenv,putenv 还是使用os.environ进行环境变量的操作,都是只对当前脚本,临时设置而已,无法直接更新或者操作系统的环境变量设置。
os.path模块
  • os.path是os模块中的子模块,包含很多和路径相关的操作
  • 函数部分:
序号函数名称描述格式
1abspath()将一个相对路径转化为绝对路径格式:os.path.abspath(相对路径) 返回值:绝对路径字符串
2basename()获取路径中的文件夹或者文件名称 (只要路径的最后一部分)格式:os.path.basename(路径) 返回值:路径的最后一部分(可能是文件名也可能是文件夹名)
3dirname()获取路径中的路径部分(出去最后一部分)格式:os.path.dirname(路径) 返回值:路径中除了最后一部分的内容字符串
4join()将2个路径合成一个路径格式:os.path.join(路径1,路径2) 返回值:合并之后的路径
5split()将一个路径切割成文件夹和文件名部分格式:os.path.split(路径) 返回值:元组
6splitext()将一个文件名切成名字和后缀两个部分格式:os.path.splitext(文件名称) 返回值:元组 (名称,后缀)
7getsize()获取一个文件的大小格式:os.path.getsize(路径) 返回值:整数
8isfile()检测一个路径是否是一个文件格式:os.path.isfile(路径) 返回值:布尔值
9isdir()检测一个路径是否是一个文件夹格式:os.path.isdir(路径) 返回值:布尔值
10getctime()获取文件的创建时间! get create time格式:os.path.getctime(文件路径) 返回值:时间戳浮点数
11getmtime()获取文件的修改时间! get modify time格式:os.path.getmtime(文件路径) 返回值:时间戳浮点数
12getatime()获取文件的访问时间! get active time格式:os.path.getatime(文件路径) 返回值:时间戳浮点数
13exists()检测指定的路径是否存在格式:os.path.exists(路径) 返回值:布尔值
14isabs()检测一个路径是否是绝对路径格式:os.path.isabs(路径) 返回值:布尔值
15islink()检测一个路径是否是链接格式:os.path.islink(路径) 返回值:布尔值
16samefile()检测2个路径是否指向同一个文件格式:os.path.samefile(路径1,路径2) 返回值:布尔值

10 Python运算符【扩展内容】

  • 本章节主要说明Python的运算符。举个简单的例子 4 +5 = 9 。 例子中,4 和 5 被称为操作数,"+" 称为运算符。
  • Python语言支持以下类型的运算符:
    1. 算术运算符
    2. 比较(关系)运算符
    3. 赋值运算符
    4. 逻辑运算符
    5. 位运算符
    6. 成员运算符
    7. 身份运算符
    8. 运算符优先级

10.1 Python算术运算符:

  • 以下假设变量a为10,变量b为21:
运算符描述实例
+加 - 两个对象相加a + b 输出结果 31
-减 - 得到负数或是一个数减去另一个数a - b 输出结果 -11
*乘 - 两个数相乘或是返回一个被重复若干次字串a * b 输出结果 210
/除 - x 除以 yb / a 输出结果 2.1
%取模 - 返回除法的余数b % a 输出结果 1
**幂 - 返回x的y次幂a**b 为10的21次方
//取整除 - 返回商的整数部分9//2 输出结果 4 , 9.0//2.0 输出结果 4.0

10.2 Python比较运算符:

  • 以下假设变量a为10,变量b为20:
运算符描述实例
==等于 - 比较对象是否相等(a == b) 返回 False。
!=不等于 - 比较两个对象是否不相等(a != b) 返回 True。
>大于 - 返回x是否大于y(a > b) 返回 False。
<小于 - 返回x是否小于y。返回1表示真,返回0表示假。 这分别与特殊的变量True和False等价。注意,这些变量名的大写。(a < b) 返回 True。
>=大于等于 - 返回x是否大于等于y。(a >= b) 返回 False。
<=小于等于 - 返回x是否小于等于y。(a <= b) 返回 True。

10.3 Python赋值运算符:

  • 以下假设变量a为10,变量b为20:
运算符描述实例
=简单的赋值运算符c = a + b 将 a + b 的运算结果赋值为 c
+=加法赋值运算符c += a 等效于 c = c + a
-=减法赋值运算符c -= a 等效于 c = c - a
*=乘法赋值运算符c *= a 等效于 c = c * a
/=除法赋值运算符c /= a 等效于 c = c / a
%=取模赋值运算符c %= a 等效于 c = c % a
**=幂赋值运算符c **= a 等效于 c = c ** a
//=取整除赋值运算符c //= a 等效于 c = c // a

10.4 Python位运算符:

  • 按位运算符是把数字看作二进制来进行计算的。Python中的按位运算法则如下:
  • 下表中变量 a 为 60,b 为 13二进制格式如下:
>>> a=18        
>>> bin(a)      # 将变量a的数值转成二进制数值输出
'0b10010'

>>> b = 0b10010  #将二进制的数值赋给变量b
>>> b
18

# 下面是二进制运算
a = 0011 1100
b = 0000 1101
-----------------
a&b = 0000 1100
a|b = 0011 1101
a^b = 0011 0001
~a  = 1100 0011
运算符描述实例
&按位与运算符:参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0(a & b) 输出结果 12 ,二进制解释: 0000 1100
l按位或运算符:只要对应的二个二进位有一个为1时,结果位就为1。(a l b) 输出结果 61 ,二进制解释: 0011 1101
^按位异或运算符:当两对应的二进位相异时,结果为1(a ^ b) 输出结果 49 ,二进制解释: 0011 0001
~按位取反运算符:对数据的每个二进制位取反,即把1变为0,把0变为1。~x 类似于 -x-1(~a ) 输出结果 -61 ,二进制解释: 1100 0011, 在一个有符号二进制数的补码形式。
<<左移动运算符:运算数的各二进位全部左移若干位,由"<<"右边的数指定移动的位数,高位丢弃,低位补0。a << 2 输出结果 240 ,二进制解释: 1111 0000
>>右移动运算符:把">>“左边的运算数的各二进位全部右移若干位,”>>"右边的数指定移动的位数a >> 2 输出结果 15 ,二进制解释: 0000 1111

(5). Python逻辑运算符:

  • Python语言支持逻辑运算符,以下假设变量 a 为 10, b为 20:
运算符逻辑表达式描述实例
andx and y布尔"与" - 如果 x 为 False,x and y 返回 False,否则它返回 y 的计算值。(a and b) 返回 20。
orx or y布尔"或" - 如果 x 是 True,它返回 x 的值,否则它返回 y 的计算值。(a or b) 返回 10。
notnot x布尔"非" - 如果 x 为 True,返回 False 。如果 x 为 False,它返回 True。not(a and b) 返回 False

10.5 Python成员运算符:

  • 除了以上的一些运算符之外,Python还支持成员运算符,测试实例中包含了一系列的成员,包括字符串,列表或元组。
运算符描述实例
in如果在指定的序列中找到值返回 True,否则返回 False。x 在 y 序列中 , 如果 x 在 y 序列中返回 True。
not in如果在指定的序列中没有找到值返回 True,否则返回 False。x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。
#!/usr/bin/python3

a = 10
b = 20
list = [1, 2, 3, 4, 5 ];

if ( a in list ):
   print ("1 - 变量 a 在给定的列表中 list 中")
else:
   print ("1 - 变量 a 不在给定的列表中 list 中")

if ( b not in list ):
   print ("2 - 变量 b 不在给定的列表中 list 中")
else:
   print ("2 - 变量 b 在给定的列表中 list 中")

# 修改变量 a 的值
a = 2
if ( a in list ):
   print ("3 - 变量 a 在给定的列表中 list 中")
else:
   print ("3 - 变量 a 不在给定的列表中 list 中")

以上实例输出结果:

1 - 变量 a 不在给定的列表中 list 中
2 - 变量 b 不在给定的列表中 list 中
3 - 变量 a 在给定的列表中 list 中

10.6 Python身份运算符

  • 身份运算符用于比较两个对象的存储单元
运算符描述实例
isis是判断两个标识符是不是引用自一个对象x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True,否则返回 False
is notis not 是判断两个标识符是不是引用自不同对象x is not y , 类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True,否则返回 False。
  • 注: id() 函数用于获取对象内存地址。
#!/usr/bin/python3

a = 20
b = 20

if ( a is b ):
   print ("1 - a 和 b 有相同的标识")
else:
   print ("1 - a 和 b 没有相同的标识")

if ( id(a) == id(b) ):
   print ("2 - a 和 b 有相同的标识")
else:
   print ("2 - a 和 b 没有相同的标识")

# 修改变量 b 的值
b = 30
if ( a is b ):
   print ("3 - a 和 b 有相同的标识")
else:
   print ("3 - a 和 b 没有相同的标识")

if ( a is not b ):
   print ("4 - a 和 b 没有相同的标识")
else:
   print ("4 - a 和 b 有相同的标识")
  • 以上实例输出结果:
1 - a 和 b 有相同的标识
2 - a 和 b 有相同的标识
3 - a 和 b 没有相同的标识
4 - a 和 b 没有相同的标识
is 与 == 区别:
# is 用于判断两个变量引用对象是否为同一个, == 用于判断引用变量的值是否相等。
>>>a = [1, 2, 3]
>>> b = a
>>> b is a 
True
>>> b == a
True
>>> b = a[:]   # 其中[:]表示复制传值
>>> b is a
False
>>> b == a
True

10.7 Python运算符优先级:

  • 以下表格列出了从最高到最低优先级的所有运算符:
运算符描述
**指数 (最高优先级)
~ + -按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)
* / % //乘,除,取模和取整除
+ -加法减法
>> <<右移,左移运算符
&位 ‘AND’
^ l位运算符
<= < > >=比较运算符
<> == !=等于运算符
= %= /= //= -= += *= **=赋值运算符
is is not身份运算符
in not in成员运算符
not or and逻辑运算符

11 Python数据类型的操作【扩展内容】

11.1 Number数字

11.1.1 数学函数

函数返回值 ( 描述 )
abs(x)返回数字的绝对值,如abs(-10) 返回 10
ceil(x)返回数字的上入整数,如math.ceil(4.1) 返回 5
cmp(x, y)如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1。 Python 3 已废弃 。使用 使用 (x>y)-(x<y) 替换。
exp(x)返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045
fabs(x)返回数字的绝对值,如math.fabs(-10) 返回10.0
floor(x)返回数字的下舍整数,如math.floor(4.9)返回 4
log(x)如math.log(math.e)返回1.0,math.log(100,10)返回2.0
log10(x)返回以10为基数的x的对数,如math.log10(100)返回 2.0
max(x1, x2,…)返回给定参数的最大值,参数可以为序列。
min(x1, x2,…)返回给定参数的最小值,参数可以为序列。
modf(x)返回x的整数部分与小数部分,两部分的数值符号与x相同,整数部分以浮点型表示。
pow(x, y)x**y 运算后的值。
round(x [,n])返回浮点数x的四舍五入值,如给出n值,则代表舍入到小数点后的位数。
sqrt(x)返回数字x的平方根。

11.1.2 随机数函数

函数描述
choice(seq)从序列的元素中随机挑选一个元素,比如random.choice(range(10)),从0到9中随机挑选一个整数。
randrange ([start,] stop [,step])从指定范围内,按指定基数递增的集合中获取一个随机数,基数缺省值为1
random()随机生成下一个实数,它在[0,1)范围内。
seed([x])改变随机数生成器的种子seed。如果你不了解其原理,你不必特别去设定seed,Python会帮你选择seed。
shuffle(lst)将序列的所有元素随机排序
uniform(x, y)随机生成下一个实数,它在[x,y]范围内。

11.1.3 三角函数

函数描述
acos(x)返回x的反余弦弧度值。
asin(x)返回x的反正弦弧度值。
atan(x)返回x的反正切弧度值。
atan2(y, x)返回给定的 X 及 Y 坐标值的反正切值。
cos(x)返回x的弧度的余弦值。
hypot(x, y)返回欧几里德范数 sqrt(xx + yy)。
sin(x)返回的x弧度的正弦值。
tan(x)返回x弧度的正切值。
degrees(x)将弧度转换为角度,如degrees(math.pi/2) , 返回90.0
radians(x)将角度转换为弧度

11.1.4 数学常量

常量描述
pi数学常量 pi(圆周率,一般以π来表示)
e数学常量 e,e即自然常数(自然常数)。

11.2 String字符串

11.2.1 Python转义字符

转义字符描述
(在行尾时)续行符
\反斜杠符号
单引号
"双引号
\a响铃
\b退格(Backspace)
\e转义
\000
\n换行
\v纵向制表符
\t横向制表符
\r回车
\f换页
\oyy八进制数,yy代表的字符,例如:\o12代表换行
\xyy十六进制数,yy代表的字符,例如:\x0a代表换行
\other其它的字符以普通格式输出

11.2.2 Python字符串运算符

  • 下表实例变量a值为字符串 “Hello”,b变量值为 “Python”:
操作符描述实例
+字符串连接a + b 输出结果: HelloPython
*重复输出字符串a*2 输出结果:HelloHello
[]通过索引获取字符串中字符a[1] 输出结果 e
[ : ]截取字符串中的一部分a[1:4] 输出结果 ell
in成员运算符 - 如果字符串中包含给定的字符返回 TrueH in a 输出结果 1
not in成员运算符 - 如果字符串中不包含给定的字符返回 TrueM not in a 输出结果 1
r/R原始字符串 - 原始字符串:所有的字符串都是直接按照字面 的意思来使用,没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母"r"(可以大 小写)以外,与普通字符串有着几乎完全相同的语法。print r’\n’ prints \n 和 print R’\n’ prints \n
%格式字符串请看下一节内容。
#!/usr/bin/python3

a = "Hello"
b = "Python"

print("a + b 输出结果:", a + b)
print("a * 2 输出结果:", a * 2)
print("a[1] 输出结果:", a[1])
print("a[1:4] 输出结果:", a[1:4])

if( "H" in a) :
    print("H 在变量 a 中")
else :
    print("H 不在变量 a 中")

if( "M" not in a) :
    print("M 不在变量 a 中")
else :
    print("M 在变量 a 中")

print (r'\n')
print (R'\n')
  • 以上实例输出结果为:
a + b 输出结果: HelloPython
a * 2 输出结果: HelloHello
a[1] 输出结果: e
a[1:4] 输出结果: ell
H 在变量 a 中
M 不在变量 a 中
\n
\n

11.2.3 Python字符串格式化:

  • Python 支持格式化字符串的输出 。尽管这样可能会用到非常复杂的表达式,但最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。
  • 在 Python 中,字符串格式化使用与 C 中 sprintf 函数一样的语法。
#!/usr/bin/python3

print ("我叫 %s 今年 %d 岁!" % ('小明', 10))

# 以上实例输出结果:
# 我叫 小明 今年 10 岁!

*python字符串格式化符号:

符 号描述
%c格式化字符及其ASCII码
%s格式化字符串
%d格式化整数
%u格式化无符号整型
%o格式化无符号八进制数
%x格式化无符号十六进制数
%X格式化无符号十六进制数(大写)
%f格式化浮点数字,可指定小数点后的精度
%e用科学计数法格式化浮点数
%E作用同%e,用科学计数法格式化浮点数
%g%f和%e的简写
%G%f 和 %E 的简写
%p用十六进制数格式化变量的地址
  • 格式化操作符辅助指令:
符号功能
*定义宽度或者小数点精度
-用做左对齐
+在正数前面显示加号( + )
在正数前面显示空格
#在八进制数前面显示零(‘0’),在十六进制前面显示’0x’或者’0X’(取决于用的是’x’还是’X’)
0显示的数字前面填充’0’而不是默认的空格
%‘%%‘输出一个单一的’%’
(var)映射变量(字典参数)
m.n.m 是显示的最小总宽度,n 是小数点后的位数(如果可用的话)
  • Python2.6 开始,新增了一种格式化字符串的函数 str.format(),它增强了字符串格式化的功能。

11.2.4 Python 的字符串内建函数:

序号名称描述
1capitalize()将字符串的第一个字符转换为大写
2center(width, fillchar)返回一个指定的宽度 width 居中的字符串,fillchar 为填充的字符,默认为空格。
3count(str, beg= 0,end=len(string))返回 str 在 string 里面出现的次数,如果 beg 或者 end 指定则返回指定范围内 str 出现的次数
4bytes.decode(encoding=“utf-8”, errors=“strict”)Python3 中没有 decode 方法,但我们可以使用 bytes 对象的 decode() 方法来解码给定的 bytes 对象,这个 bytes 对象可以由 str.encode() 来编码返回。
5encode(encoding=‘UTF-8’,errors=‘strict’)以 encoding 指定的编码格式编码字符串,如果出错默认报一个ValueError 的异常,除非 errors 指定的是’ignore’或者’replace’
6endswith(suffix, beg=0, end=len(string))检查字符串是否以 obj 结束,如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束,如果是,返回 True,否则返回 False.
7expandtabs(tabsize=8)把字符串 string 中的 tab 符号转为空格,tab 符号默认的空格数是 8 。
8find(str, beg=0 end=len(string))检测 str 是否包含在字符串中,如果指定范围 beg 和 end ,则检查是否包含在指定范围内,如果包含返回开始的索引值,否则返回-1
9index(str, beg=0, end=len(string))跟find()方法一样,只不过如果str不在字符串中会报一个异常.
10isalnum()如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True,否则返回 False
11isalpha()如果字符串至少有一个字符并且所有字符都是字母则返回 True, 否则返回 False
12isdigit()如果字符串只包含数字则返回 True 否则返回 False…
13islower()如果字符串中包含至少一个区分大小写的字符,并且所有这些(区分大小写的)字符都是小写,则返回 True,否则返回 False
14isnumeric()如果字符串中只包含数字字符,则返回 True,否则返回 False
15isspace()如果字符串中只包含空白,则返回 True,否则返回 False.
16istitle()如果字符串是标题化的(见 title())则返回 True,否则返回 False
17isupper()如果字符串中包含至少一个区分大小写的字符,并且所有这些(区分大小写的)字符都是大写,则返回 True,否则返回 False
18join(seq)以指定字符串作为分隔符,将 seq 中所有的元素(的字符串表示)合并为一个新的字符串
19len(string)返回字符串长度
20ljust(width[, fillchar])返回一个原字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串,fillchar 默认为空格。
21lower()转换字符串中所有大写字符为小写.
22lstrip()截掉字符串左边的空格或指定字符。
23maketrans()创建字符映射的转换表,对于接受两个参数的最简单的调用方式,第一个参数是字符串,表示需要转换的字符,第二个参数也是字符串表示转换的目标。
24max(str)返回字符串 str 中最大的字母。
25min(str)返回字符串 str 中最小的字母。
26replace(old, new [, max])把 将字符串中的 str1 替换成 str2,如果 max 指定,则替换不超过 max 次。
27rfind(str, beg=0,end=len(string))类似于 find()函数,不过是从右边开始查找.
28rindex( str, beg=0, end=len(string))类似于 index(),不过是从右边开始.
29rjust(width,[, fillchar])返回一个原字符串右对齐,并使用fillchar(默认空格)填充至长度 width 的新字符串
30rstrip()删除字符串字符串末尾的空格.
31split(str="", num=string.count(str))num=string.count(str)) 以 str 为分隔符截取字符串,如果 num 有指定值,则仅截取 num 个子字符串
32splitlines([keepends])按照行(’\r’, ‘\r\n’, \n’)分隔,返回一个包含各行作为元素的列表,如果参数 keepends 为 False,不包含换行符,如果为 True,则保留换行符。
33startswith(str, beg=0,end=len(string))检查字符串是否是以 obj 开头,是则返回 True,否则返回 False。如果beg 和 end 指定值,则在指定范围内检查。
34strip([chars])在字符串上执行 lstrip()和 rstrip()
35swapcase()将字符串中大写转换为小写,小写转换为大写
36title()返回"标题化"的字符串,就是说所有单词都是以大写开始,其余字母均为小写(见 istitle())
37translate(table, deletechars="")根据 str 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 deletechars 参数中
38upper()转换字符串中的小写字母为大写
39zfill (width)返回长度为 width 的字符串,原字符串右对齐,前面填充0
40isdecimal()检查字符串是否只包含十进制字符,如果是返回 true,否则返回 false。

11.3 List列表

  • 序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字 - 它的位置,或索引,第一个索引是0,第二个索引是1,依此类推。
  • 列表操作实例:
#!/usr/bin/python3

# 定义 
list0 = [] # 创建一个空列表 或者  变量 = list()
list1 = ['Google', 'Python', 1997, 2000];
list2 = [1, 2, 3, 4, 5, 6, 7 ];

#输出
print ("list1[0]: ", list1[0])  # Google
print ("list2[1:5]: ", list2[1:5]) # [2, 3, 4, 5]

#更新其中的值
print ("第三个元素为 : ", list[2])    # 2000
list[2] = 2001
print ("更新后的第三个元素为 : ", list[2])  # 2001

#删除其中一个元素
del list[2]
print ("删除第三个元素 : ", list)  #  ['Google', 'Python', 2000]

11.3.1 列表的遍历操作:

1.使用for...in 遍历列表

    for 变量 in 列表:
        使用变量

2.使用while循环遍历列表

    i = 0
    while i<len(列表):
        使用列表中的元素(列表[i])
        i += 1

3.同等长度二级列表的遍历

    列表 = [[1,2],[1,2],....]

    for 变量1,变量2 in 列表:
        使用变量1和变量2

    注意:变量1取二级列表中的第一个值,变量2取第二个值
4.非同等长度的二级列表的遍历

    列表 = [[1,值2][1,值2,3],[]...]

    for 变量1 in 列表:
        for 变量2 in 变量1:
            使用变量2(变量2是二级列表中的每个值)

11.3.2 Python列表脚本操作符:

  • 列表对 + 和 的操作符与字符串相似。+ 号用于组合列表, 号用于重复列表。
Python 表达式结果描述
len([1, 2, 3])3长度
[1, 2, 3] + [4, 5, 6][1, 2, 3, 4, 5, 6]组合
[‘Hi!’] * 4[‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’]重复
3 in [1, 2, 3]True元素是否存在于列表中
for x in [1, 2, 3]: print(x, end=" ")1 2 3迭代

11.3.3 Python列表截取与拼接:

  • Python的列表截取与字符串操作类型,如下所示:L=[‘Google’, ‘Python’, ‘Taobao’]
Python表达式 结果描述
L[2]‘Taobao’读取第三个元素
L[-2]‘Python’从右侧开始读取倒数第二个元素: count from the right
L[1:][‘Python’, ‘Taobao’]输出从第二个元素开始后的所有元素
  • 使用嵌套列表即在列表里创建其它列表,例如:
>>>a = ['a', 'b', 'c']
>>> n = [1, 2, 3]
>>> x = [a, n]
>>> x
[['a', 'b', 'c'], [1, 2, 3]]
>>> x[0]
['a', 'b', 'c']
>>> x[0][1]
'b'

11.3.4 Python列表函数&方法:

  • Python包含以下函数:
序号函数名称说明
1len(list)列表元素个数
2max(list)返回列表元素最大值
3min(list)返回列表元素最小值
4list(seq)将元组转换为列表
  • Python包含以下方法:
序号方法名称说明
1list.append(obj)在列表末尾添加新的对象
2list.count(obj)统计某个元素在列表中出现的次数
3list.extend(seq)在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表)
4list.index(obj)从列表中找出某个值第一个匹配项的索引位置
5list.insert(index, obj)将对象插入列表
6list.pop(obj=list[-1])移除列表中的一个元素(默认最后一个元素),并且返回该元素的值
7list.remove(obj)移除列表中某个值的第一个匹配项
8list.reverse()反向列表中元素
9list.sort([func])对原列表进行排序
10list.clear()清空列表
11list.copy()复制列表

11.4 Tuple元组

  • Python 的元组与列表类似,不同之处在于元组的元素不能修改。
  • 元组使用小括号,列表使用方括号。
  • 元组创建很简单,只需要在括号中添加元素,并使用逗号隔开即可。
# 定义元组的方式:
tup0 = ()  #定义一个空元组 或者 变量 = tuple()
tup1 = ('Google', 'Python', 1997, 2000)
tup2 = (1, 2, 3, 4, 5 )
tup3 = "a", "b", "c", "d"

# 输出元组:
print ("tup1[0]: ", tup1[0])       # tup1[0]:  Google
print ("tup2[1:5]: ", tup2[1:5])   # tup2[1:5]:  (2, 3, 4, 5)

# 注意下面这种定义不加逗号,类型为整型
tup4 = (50)
print(type(tup4))  # <class 'int'>

# 正确定义方式加上逗号,类型为元组
tup5 = (50,)
print(type(tup5))  # <class 'tuple'>

# 以下修改元组元素操作是非法的。
# tup1[0] = 100

#元组中的元素值是不允许删除的,但我们可以使用del语句来删除整个元组
del tup0;

11.4.1 元组运算符:

  • 与字符串一样,元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制,运算后会生成一个新的元组。
Python 表达式结果描述
len((1, 2, 3))3长度
(1, 2, 3) + (4, 5, 6)(1, 2, 3, 4, 5, 6)组合
(‘Hi!’) * 4(‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’)重复
3 in (1, 2, 3)True元素是否存在于元组中
for x in (1, 2, 3): print(x, end=" ")1 2 3迭代

11.4.2 元组索引,截取:

  • 因为元组也是一个序列,所以我们可以访问元组中的指定位置的元素,也可以截取索引中的一段元素
  • 如下所示:L=(‘Google’, ‘Python’, ‘Taobao’)
Python表达式 结果描述
L[2]‘Taobao’读取第三个元素
L[-2]‘Python’从右侧开始读取倒数第二个元素: count from the right
L[1:](‘Python’, ‘Taobao’)输出从第二个元素开始后的所有元素

11.4.3元组内置函数:

  • Python元组包含了以下内置函数:
序号函数名称说明
1len(tuple)元组元素个数
2max(tuple)返回元组元素最大值
3min(tuple)返回元组元素最小值
4tuple(seq)将元组转换为元组
list1= ['Google', 'Taobao', 'Runoob', 'Baidu']

tuple1=tuple(list1)

print(tuple1)

#('Google', 'Taobao', 'Runoob', 'Baidu')

11.5 set集合

  • 集合(set)是一个无序不重复元素的序列。
  • 基本功能是进行成员关系测试和删除重复元素。
  • 可以使用大括号 { } 或者 set() 函数创建集合,注意:创建一个空集合必须用 set() 而不是 { },因为 { } 是用来创建一个空字典。
# 集合的定义
set1 = set()  #定义一个空的集合
set2 = {1,2,3}

# 增加一个元素
set1.add(5)  

#增加多个:
set1.update([5,6,7,8])

#删除某个值
set1.remove(1)

#查:无法通过下标索引

#改:不可变类型无法修改元素

a={10,20,30}
b={20,50}
print(a - b)     # a和b的差集 

print(a | b)     # a和b的并集

print(a & b)     # a和b的交集

print(a ^ b)     # a和b中不同时存在的元素

11.5.1 集合的遍历:

1.普通序列的遍历

    for 变量 in 集合:
        使用变量

2.多级集合

    集合 = {(值,..,(值,值..)。。。}

    for 变量1,变量2 in 集合:

        使用变量1和变量2

11.5.2 集合的序列函数:

  • len() 计算集合的长度
  • max() 获取集合中的最大值
  • min() 获取集合中的最小值
  • set() 创建空集合或者将其他数据转换为集合

11.5.3 集合中的方法:

  • add – 增加集合元素
name = {'d', 's'}
name.add('d')
name
返回结果:{'d', 's'}
name.add('sd')
name
返回结果:{'sd', 'd', 's'}
  • update–更新已有集合
name = {'sd', 'd', 's'}
name.update('df')
name
返回结果:{'sd', 'd', 'f', 's'}
  • remove–移除指定集合元素
name = {'sd','d','s'}
name.remove('s')
返回结果:name
{'sd', 'd'}
  • discard–移除元素
name = {'sd', 'd', 's'}
name.discard('s')

返回结果:name 
        {'sd', 'd'}

# remove移除非成员值会报错,discard移除非成员值,啥也不错!
  • clear–清空集合元素
name = {'d', 's'}
name.clear()
name

返回结果:{}
  • copy–浅拷贝
name = {'sd', 'd', 's'}
li = name.copy()

返回结果:li
        {'sd', 'd', 's'}
  • difference – 求差集
name.difference(li)
set()
>>> name.difference()
{'sd', 'd', 's'}
  • union–并集,创建新的对象
name = {'sd', 'd', 's'}
li = {'s', 'd','h'}
name.union(li)
返回结果:{'h', 's', 'd', 'sd'}
  • difference_update—删除当前set中的所有包含在 new set 里的元素
li = ('s', 'd')
name = {'sd', 'd', 's'}
name.difference_update(li)
name
返回结果:{'sd'}
  • intersection–取交集,建立新的set集合
li = ('s', 'd')
name = {'sd', 'd', 's'}
name.intersection(li)
返回结果:{'d', 's'}
  • intersection_update–取交集,更新原来的set集合
li = ('s', 'd')
name = {'sd', 'd', 's'}
name.intersection_update(li)
返回结果:{'d', 's'}
  • isdisjoint–判断没有交集,返回True,否则,返回False
li = {'s', 'd'}
name = {'sd', 'd', 's'}
name.isdisjoint(li)
  • issubset–判断是否是子集
li = {'s', 'd'}
name = {'sd', 'd', 's'}
name.issubset(li)  #判断name是不是li的子集
返回结果:False

li.issubset(name)  #判断li是不是name的子集
返回结果:True
  • issuperset–判断是否是父集
li = {'s', 'd'}
name = {'sd', 'd', 's'}
name.issuperset(li)  #判断name是不是li的父集
返回结果:True

li.issuperset(name)  #判断li是不是name的父集
返回结果:False
  • pop–移除集合元素
name = {'sd', 'd', 's'}
name.pop()
返回结果:'sd' #同一个集合,删除集合元素的顺序固定

se1 = {'a','s','sb'}
se1.pop()
返回结果:'sb'
  • symmetric_difference–去两个集合的差集,建立新的set集合对象
name = {'sd', 'd', 's'}
li = {'s', 'd'}
name.symmetric_difference(li)
返回结果:{'sd'}
  • symmetric_difference_update–去两个集合的差集,更新原来的集合对象
name = {'sd', 'd', 's'}
li = {'s', 'd'}
name.symmetric_difference_update(li)
返回结果:{'sd'}

11.6 Dictionary字典

  • 字典是另一种可变容器模型,且可存储任意类型对象。
  • 字典的每个键值(key=>value)对用冒号(:)分割,每个对之间用逗号(,)分割,整个字典包括在花括号({})中 ,格式如下所示:
d = {key1 : value1, key2 : value2 }
  • 键必须是唯一的,但值则不必。

11.6.1 创建字典:

1.创建空字典
    变量 = {} 或者 变量 = dict()

2.创建多个元素的字典:
    方法1:
        变量 = {键:值,键:值....}

    方法2:
        变量 = dict({键:值,键:值....})

    方法3:
        变量 = dict(键=值,键=值...)
        注意:该方式键作为形参名使用不可以添加引号,必须符合变量规则

    方法4:
        变量 = dict([(键,值),(键,值)...])
        变量 = dict([[键,值],[键,值]...])
        变量 = dict(((键,值),(键,值)...))

    方法5:
        变量 = dict(zip((键,键...),(值,值...)))

11.6.2 字典的基本操作:

访问字典的元素:
    变量[键]

添加字典的元素
    变量[新键] = 值

修改字典元素
    变量[键] = 新值

删除字典元素
    del 变量[键]
  • 案例:
#!/usr/bin/python3

# 定义一个字典
dict = {'Name': 'Python', 'Age': 17, 'Class': 'First'}

# 输出子典中的信息
print ("dict['Name']: ", dict['Name']) #Python
print ("dict['Age']: ", dict['Age'])   #17

# 输出错误信息:KeyError: 'Alice'
#print ("dict['Alice']: ", dict['Alice'])


# 修改和添加内容
dict['Age'] = 18;              # 更新 Age
dict['School'] = "云课堂"      # 添加信息

# 删除信息
del dict['Name'] # 删除键 'Name'一个元素值
dict.clear()     # 清空字典
del dict         # 删除字典

11.6.3 字典的遍历:

1.键的遍历
    for 变量i in 字典:
        使用i遍历所有的键,有键就可以通过变量访问其值

2.键值遍历
    for 变量i,变量j in 字典.items():
        使用变量i遍历所有键,通过变量j遍历所有值

11.6.4 字典内涵/字典推导式:

1.普通的字典内涵
    变量= {key:value for key,value in 字典.items()}

2.带有判断条件的字典内涵
    变量= {key:value for key,value in 字典.items() if 条件表达式}

3,多个循环的字典内涵
    变量 = {i+x:j+y for i,j in 字典1.items for x,y in 字典2.items()}

4.带有判断条件的多个循环的字典内涵
    变量 = {i+x:j+y for i,j in 字典1.items for x,y in 字典2.items() if 条件表达式}

11.6.5 字典内置函数&方法:

  • Python字典包含了以下内置函数:
序号函数名称描述实例
1len(dict)计算字典元素个数, 即键的总数。>>> dict = {‘Name’: ‘py’, ‘Age’: 7, ‘Class’: ‘First’} >>> len(dict) 3
2str(dict)输出字典, 以可打印的字符串表示。>>> dict = {‘Name’: ‘py’, ‘Age’: 7, ‘Class’: ‘First’} >>> str(dict) “{‘Name’: ‘py’, ‘Class’: ‘First’, ‘Age’: 7}”
3type(variable)返回输入的变量类型, 如果变量是字典 就返回字典类型。>>> dict = {‘Name’: ‘py’, ‘Age’: 7, ‘Class’: ‘First’} >>> type(dict) <class ‘dict’>
  • Python字典包含了以下内置方法:
序号方法名称描述
1radiansdict.clear()删除字典内所有元素
2radiansdict.copy()返回一个字典的浅复制
3radiansdict.fromkeys()创建一个新字典,以序列seq中元素做字典的键,val为字典所有键对应的初始值
4radiansdict.get(key, default=None)返回指定键的值,如果值不在字典中返回default值
5key in dict如果键在字典dict里返回true,否则返回false
6radiansdict.items()以列表返回可遍历的(键, 值) 元组数组
7radiansdict.keys()以列表返回一个字典所有的键
8radiansdict.setdefault(key, default=None)和get()类似, 但如果键不存在于字典中,将会添加键并将值设为default
9radiansdict.update(dict2)把字典dict2的键/值对更新到dict里
10radiansdict.values()以列表返回字典中的所有值
11pop(key[,default])删除字典给定键 key 所对应的值,返回值为被删除的值。key值必须给出。 否则,返回default值。
12popitem()随机返回并删除字典中的一对键和值(一般删除末尾对)。

{key:value for key,value in 字典.items()}

2.带有判断条件的字典内涵
变量= {key:value for key,value in 字典.items() if 条件表达式}

3,多个循环的字典内涵
变量 = {i+x:j+y for i,j in 字典1.items for x,y in 字典2.items()}

4.带有判断条件的多个循环的字典内涵
变量 = {i+x:j+y for i,j in 字典1.items for x,y in 字典2.items() if 条件表达式}


#### 11.6.5 字典内置函数&方法:

- Python字典包含了以下内置函数:

| 序号 | 函数名称       | 描述                                                 | 实例                                                         |
| ---- | -------------- | ---------------------------------------------------- | ------------------------------------------------------------ |
| 1    | len(dict)      | 计算字典元素个数, 即键的总数。                      | >>> dict = {'Name': 'py', 'Age': 7, 'Class': 'First'}  >>> len(dict)   3 |
| 2    | str(dict)      | 输出字典, 以可打印的字符串表示。                    | >>> dict = {'Name': 'py', 'Age': 7, 'Class': 'First'}   >>> str(dict)   "{'Name': 'py', 'Class': 'First', 'Age': 7}" |
| 3    | type(variable) | 返回输入的变量类型, 如果变量是字典 就返回字典类型。 | >>> dict = {'Name': 'py', 'Age': 7, 'Class': 'First'}   >>> type(dict)   <class 'dict'> |

- Python字典包含了以下内置方法:

| 序号 | 方法名称                                  | 描述                                                         |
| ---- | ----------------------------------------- | ------------------------------------------------------------ |
| 1    | radiansdict.clear()                       | 删除字典内所有元素                                           |
| 2    | radiansdict.copy()                        | 返回一个字典的浅复制                                         |
| 3    | radiansdict.fromkeys()                    | 创建一个新字典,以序列seq中元素做字典的键,val为字典所有键对应的初始值 |
| 4    | radiansdict.get(key, default=None)        | 返回指定键的值,如果值不在字典中返回default值                |
| 5    | key in dict                               | 如果键在字典dict里返回true,否则返回false                    |
| 6    | radiansdict.items()                       | 以列表返回可遍历的(键, 值) 元组数组                          |
| 7    | radiansdict.keys()                        | 以列表返回一个字典所有的键                                   |
| 8    | radiansdict.setdefault(key, default=None) | 和get()类似, 但如果键不存在于字典中,将会添加键并将值设为default |
| 9    | radiansdict.update(dict2)                 | 把字典dict2的键/值对更新到dict里                             |
| 10   | radiansdict.values()                      | 以列表返回字典中的所有值                                     |
| 11   | pop(key[,default])                        | 删除字典给定键 key 所对应的值,返回值为被删除的值。key值必须给出。 否则,返回default值。 |
| 12   | popitem()                                 | 随机返回并删除字典中的一对键和值(一般删除末尾对)。           |

©️2020 CSDN 皮肤主题: 游动-白 设计师:上身试试 返回首页