本文假设你已经有一门面向对象编程语言基础,如Java等,且希望快速了解并使用Python语言。本文对重点语法和数据结构以及用法进行详细说明,同时对一些难以理解的点进行了图解,以便大家快速入门。一些较偏的知识点在大家入门以后根据实际需要再查询官方文档即可,学习时切忌胡子眉毛一把抓。同时,一定要跟着示例多动手写代码。学习一门新语言时推荐大家同时去刷leetcode,一来可以快速熟悉新语言的使用,二来也为今后找工作奠定基础。推荐直接在网页上刷leetcode,因为面试的时候一般会让你直接在网页编写代码。leetcode刷题路径可以按我推荐的方式去刷。以下代码中,以 >>>... 开头的行是交互模式下的代码部分,>?开头的行是交互模式下的输入,其他行是输出。python代码中使用 #开启行注释。

Python 简介

Python作为一门脚本语言,既可以在命令行以交互的方式进行程序编写和执行,也可以在*.py文件中进行编写然后通过解释器执行。前者适合验证阶段使用,后者更适合项目编写。(验证阶段更推荐使用Jupyter,在编写时可将顺序执行的代码人为的划分为相邻的代码块,执行时可以手动依次执行代码块,当某一个代码块出现错误时,修改了出错的代码块后无需再次重头执行,只需从修改处代码块接着执行即可。)

在学习的过程中,通过help()函数可以查看方法、对象等的官方文档。例如查看print函数的官方文档:

>>> help(print)
Help on built-in function print in module builtins:
print(...)
print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False) Prints the values to a stream, or to sys.stdout by default.
Optional keyword arguments:
file: a file-like object (stream); defaults to the current sys.stdout.
sep: string inserted between values, default a space.
end: string appended after the last value, default a newline.
flush: whether to forcibly flush the stream.

基本输入输出

输出:print()函数:

>>> print("sum( a + b ):", 10 + 20)
sum( a + b ): 30

如上,print 函数将前面的字符串和后面的计算结果通过空格拼接成字符串。你也可以指定sep = "\n"参数让其通过换行符拼接。如下:

>>> print("sum( a + b ): ", 10 + 20, sep = "\n")
sum( a + b ):
30

输入:input()函数,该函数默认将所有读入的数据视为字符串:

>>> a = input()
>>> print(a)
>>> print(type(a))
>? 123
123
<class 'str'="">

数据类型和变量

数值型( immutable )

int   # 整型
float # 浮点型
bool # 布尔型
complex # 复数,需要时查询文档即可,这里不做讲解

Python 作为动态语言,在定义变量时无需指定数据类型,执行时解释器会自行推断出变量类型。在PycharmPython Console选项卡(建立项目后才可以看到,在界面的最下面一行)里可以实时显示变量的类型:

Python 中除法默认返回浮点数,使用双斜杠除法//会舍去小数点后面的部分:

>>> a = 3       # 在交互模式下点击shift+enter可以实现多行代码编写
... b = 4
... print(a/b)
0.75 # / 除法返回浮点数 >>> print(a//b)
0 # // 除法舍去小数部分 >>> a = 3.0
... b = 4.0
... print(a/b)
0.75 >>> print(a//b)
0.0

Python语言中使用 **表示幂次计算,如 2 的 3 次方写为:2 ** 3

>>> print(2 ** 3)
8

Python语言中的 bool 类型分为TrueFalse(严格区分大小写),bool 类型是 int 类型的子类,且True在值上等于1False在值上等于0

>>> True == 1
True
>>> False == 0
True
>>> issubclass(bool, int)
True

提示:Python中的数值类型是引用类型而不是值类型

字符串型(immutable )

str   # 字符串型

Python中被''""引住的内容表示一个字符串,Python中的字符串与Java中的字符一样为不可变( immutable )类型。如下:

Python字符串的强大之处在于支持下标访问切片功能。通过下标访问我们可以直接拿到字符串中的某个字符(实际为只有一个字符构成的字符串),当下标为负数时表示从右侧开始:

通过切片操作,我们可以获取某个字符串的任意子串,切片由一个区间表示,如[0: len]表示获取下标0 - len-1的子串,即左闭右开。此外[:3]等同[0: 3][3:]等同[3: len]。由于每次切片操作都会返回一个新的字符串

>>> a = 'python'

>>> print(a[:3])
pyt
>>> print(a[0: 3])
pyt >>> print(a[3:])
hon
>>> print(a[3: len(a)])
hon >>> print(a[:-3]) # 从开头到倒数第三个字符表示的子串(同样符合左闭右开)
pyt
>>> print(a[-3:])
hon

Python还支持多行字符串,需要时查询文档即可。

列表类型(mutable)

list  # 列表

Python 中的列表有点类似于 JavaList接口的实现(ArryListLinkedList),是一种高级数据结构,不同之处在于 Python 中的 list 可以存储不同类型的数据,但通常并不会这样使用。list 还支持切片操作,且是可变( mutable)类型。list 由中括号包住若干被逗号分隔的元素来表示,如:[1, 2, 3]

由于list是可变类型,我们可以对list进行修改:

>>> a = ['p', 'y', 't', 'h', 'o', 'n']
>>> a[1] = 'i' # 将下标1中的元素(引用)指向字符串'i'
>>> print(a)
['p', 'i', 't', 'h', 'o', 'n'] # 第2个元素(引用)指向的字符串对象由 'y' 变为 'i'

list 的切片操作返回的新列表是原列表的一个浅拷贝。浅拷贝是对象拷贝的一种方式,由于Python中只有引用类型,下面以list类型为例对引用类型的浅拷贝进行讲解。下图是列表 a 在内存中的示意图:

变量a是一个引用(地址),它指向内存中的list对象。list对象中的每一个元素(引用)又指向内存中的int对象。当对a执行如下切片操作时:

>>> a = [1, 2, 3, 4]
>>> b = a[:2] # 1. b通过切片获取a前两个元素的浅拷贝
>>> print(a)
... print(b)
[1, 2, 3, 4]
[1, 2]
>>> b[0] = 6 # 2. 修改b[0]
>>> print(a)
... print(b)
[1, 2, 3, 4] # 修改b[0]并没有影响a,为什么呢?
[6, 2]

执行 b = a[:2]时,内存中会生成一个新的list对象,且b会指向这个新list对象,内存变化如下:

执行b[0] = 6时,内存变化如下:

由上图容易知道这种情况下修改b并不会影响a。接着往下看:

>>> a = [1, 2, 3, [0, 0]]
>>> b = a[-2:] # b通过切片获取a后两个元素的浅拷贝
>>> print(a)
... print(b)
[1, 2, 3, [0, 0]]
[3, [0, 0]]
>>> b[1][0] = 6 # 修改b[1][0]
>>> print(a)
... print(b)
[1, 2, 3, [6, 0]] # 修改b[1][0]时,影响了a
[3, [6, 0]]

执行b = a[-2:]时,内存变化如下:

执行b[1][0] = 6时,内存变化如下:

由上图容易知道,因为a[3]b[1]指向内存中同一个list,当通过b[1][0]修改b时会同时影响a

同时,我们还可以通过切片操作来修改列表:

>>> a = [1, 2, 3]
>>> a[1: 3] = [6, 6] # 修改a中后两个元素;如果这里为a[1: 3] = [6, 6, 6, 6]会出错吗?动手试试
>>> print(a)
[1, 6, 6] >>> a[:] = [] # 清空a
>>> print(a)
[]

此外,列表还支持合并与嵌套:

>>> a = [1, 2, 3]
>>> b = [4, 5, 6]
>>> c = a + b # 合并
>>> print(c)
[1, 2, 3, 4, 5, 6] >>> d = [a, b] # 嵌套
>>> print(d)
[[1, 2, 3], [4, 5, 6]]

最后,列表还提供了一系列成员方法:

  • list.append(x)

    在列表末尾添加一个元素,相当于 a[len(a):] = [x]

    >>> a = ['wjz']
    >>> a.append('lsl')
    >>> print(a)
    ['wjz', 'lsl']
  • list.extend(iterable)

    用可迭代对象的元素扩展列表。相当于 a[len(a):] = iterable

    >>> a = [1, 2, 3]
    ... b = [4, 5, 6]
    ... a.extend(b)
    ... print(a)
    [1, 2, 3, 4, 5, 6]
  • list.insert(i, x)

    在指定位置插入元素。第一个参数是插入元素的索引,因此,a.insert(0, x) 在列表开头插入元素, a.insert(len(a), x) 等同于 a.append(x)

  • list.remove(x)

    从列表中删除第一个值为 x 的元素。未找到指定元素时,触发 ValueError 异常。

  • list.pop([i])

    删除列表中指定位置的元素,并返回被删除的元素。未指定位置时,a.pop() 删除并返回列表的最后一个元素。(方法签名中 i 两边的方括号表示该参数是可选的,不是要求输入方括号。这种表示法常见于 Python 参考库)。

    >>> a = [1, 2, 3]
    >>> a.pop() # 默认为 pop(-1),即倒数第一个
    3
    >>> print(a)
    [1, 2]
    >>> a.pop(0) # 删除第一个
    1
    >>> print(a)
    [2]
  • list.clear()

    删除列表里的所有元素,相当于 del a[:]del语句可以删除一个变量,或按切片删除列表元素。

    # 删除变量
    >>> a = [1, 2, 3]
    ... b = a
    ... del a
    ... print(a) # 删除变量a后再访问a,报错:未定义
    Traceback (most recent call last):
    File "<input>", line 4, in <module>
    NameError: name 'a' is not defined
    >>> print(b) # b引用指向的列表对象还存在说明del只是删除了a这个引用
    [1, 2, 3] # del通过切片删除列表元素
    >>> a = [1, 2, 3]
    ... del a[:2]
    ... print(a)
    [3]
  • list.index(x[, start[, end]])

    返回列表中第一个值为 x 的元素的零基索引。未找到指定元素时,触发 ValueError 异常。可选参数 startend 是切片符号,用于将搜索限制为列表的特定子序列。返回的索引是相对于整个序列的开始计算的,而不是 start 参数。

    >>> a = [1, 2, 3, 4, 5]
    ... print(a.index(3))
    2 # a中3的下标为2 >>> a = [1, 2, 3, 4, 5]
    ... print(a.index(3, 2, len(a))) # 从第3个元素开始查找3
    2
  • list.count(x)

    返回列表中元素 x 出现的次数。

  • list.sort(*, key=None, reverse=False)

    就地排序列表中的元素(要了解自定义排序参数,详见 sorted())。该方法先忽略,入门2中有讲解。

  • list.reverse()

    翻转列表中的元素。

  • list.copy()

    返回列表的浅拷贝。相当于 a[:]

元组类型(immutable )

tuple  # 元组

元组与列表很相似,但元组为不可变类型,元组通常用来包含异质元素(类型不同)而列表通常用来包含同质元素。tuple 由小括号包住若干被逗号分隔的元素来表示,如:(1, 2, 3)。元组同样支持切片、下标(索引)访问。

定义一个元组:

>>> a = (1, 2, 3)
>>> b = 1, 2, 3 # 定义时省略括号也行,但不建议
>>> print(a, b)
(1, 2, 3) (1, 2, 3) # 定义一个空元组
>>> a = ()
... print(a)
() # 定义只有一个元素的元组
>>> a = (1,)
... print(type(a))
... print(a)
<class 'tuple'="">
(1,) # 没有逗号 a 就是值为 1 的int型变量
>>> a = (1)
... print(type(a))
... print(a)
<class 'int'="">
1

元组的不可变是指元组中的每一个元素(引用)的指向不能改变,以a = (1, 2, 3, 4)为例:

上图中被椭圆圈起来的四个指向都不能修改,但如果元组中元素(引用)指向的是一个可变类型,指向虽然不能修改,但可变类型本身是可以修改的,以a = ([1, 2], [3, 4])为例:

上图中被红色椭圆圈起来的指向不能修改,被蓝色椭圆圈起来的指向可以修改:

>>> a = (1, 2, 3, 4)
>>> a[0] = 6 # 不能修改a[0]的指向
Traceback (most recent call last):
File "<input>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment >>> a = ([1, 2], [3, 4])
>>> a[0] = [6, 6] # 不能修改a[0]的指向
Traceback (most recent call last):
File "<input>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> a[0][0] = 6 # a[0] 指向的list可以修改
>>> print(a)
([6, 2], [3, 4])

集合类型(mutable)

set  # 集合类型

集合是用来存放不含重复元素的无序容器。

定义集合:

# 通过花括号定义集合
>>> a = {1, 2, 3, 2}
... print(a)
{1, 2, 3} # 去重 # 通过set()函数定义集合。只能传入一个参数,且为可迭代类型。
# 会取出可迭代类型中的每一个元素为一个集合元素
>>> set("123 4") # 传入字符串
{'3', ' ', '2', '4', '1'}
>>> set(["1", "2", "3"]) # 传入list
{'3', '1', '2'} # 定义空集合只能使用set()函数
>>> a = set()
... print(type(a))
... print(a)
<class 'set'="">
set() # {}表示一个空字典
>>> a = {}
... print(type(a))
... print(a)
<class 'dict'="">
{}

字典类型(mutable)

dict  # 字典

字典类型是可变类型,类似与Java中的Map。字典类型用来存储键值对,关键字通常是字符串或数字,也可以是其他任意不可变类型。若元组直接或间接地包含了可变对象,就不能用作关键字。

创建字典:

# 创建空字典
>>> a = {}
>>> print(a)
{}
>>> a = dict()
>>> print(a)
{} # 常用创建方式
# 直接在花括号中申明键值对
>>> a = {"chengdu": "A", "mianyang": "B", "guangyuan": "C"}
>>> print(a)
{'chengdu': 'A', 'mianyang': 'B', 'guangyuan': 'C'} # 关键字传参的方式调用dict函数
>>> a = dict(chengdu="A", mianyang="B", guangyuan="C")
>>> print(a)
{'chengdu': 'A', 'mianyang': 'B', 'guangyuan': 'C'} # 构造函数中传入键值对序列
>>> a = dict((("chengdu", "A"), ("mianyang", "B"), ("guangyuan", "C")))
>>> print(a)
{'chengdu': 'A', 'mianyang': 'B', 'guangyuan': 'C'} >>> a = dict([("chengdu", "A"), ("mianyang", "B"), ("guangyuan", "C")])
>>> print(a)
{'chengdu': 'A', 'mianyang': 'B', 'guangyuan': 'C'} >>> a = dict([["chengdu", "A"], ["mianyang", "B"], ["guangyuan", "C"]])
>>> print(a)
{'chengdu': 'A', 'mianyang': 'B', 'guangyuan': 'C'}

对字典进行增删改:

>>> a = dict([["chengdu", "A"], ["mianyang", "B"], ["guangyuan", "C"]])
>>> a["zigong"] = "C" # 为不存在的key赋值即可添加新的键值对
... print(a)
{'chengdu': 'A', 'mianyang': 'B', 'guangyuan': 'C', 'zigong': 'C'} >>> del a["zigong"] # 删除key为 “zigong” 的键值对
... print(a)
{'chengdu': 'A', 'mianyang': 'B', 'guangyuan': 'C'} >>> a["guangyuan"] = "F" # 为已经存在的key赋值即可对已存在的键值对进行修改
... print(a)
{'chengdu': 'A', 'mianyang': 'B', 'guangyuan': 'F'}

常用高级数据结构

栈的特性是先进后出,使用list非常容易实现;使用append(e)将元素添加到栈顶,使用pop()将栈顶元素弹出:

>>> stack = [1, 2, 3]
>>> stack.append(4) # 4入栈
... print(stack)
[1, 2, 3, 4] >>> stack.pop() # 4出栈
... stack.pop() # 3出栈
... print(stack)
[1, 2]

队列

队列的特性是先进先出,使用list也能实现队列,即使用append(e)将元素入队尾,使用pop(0)使队头元素出队。但pop(0)操作很费时(其他元素都必须向前移动一位),故不推荐使用list实现队列。

实现队列最好用 collections.deque,可以快速从两端添加或删除元素(双端队列):

  • append():从右边入队
  • appendleft():从左边入队
  • popleft():从左边出队
  • pop():从右边出队
>>> from collections import deque
... myDeque = deque([1, 2, 3])
... print(myDeque)
... myDeque.append(4) # 4入队尾
... print(myDeque)
... myDeque.popleft() # 1出队头
... print(myDeque)
deque([1, 2, 3])
deque([1, 2, 3, 4])
deque([2, 3, 4])

Python 3 快速入门 1 —— 数据类型与变量的更多相关文章

  1. Python编程从入门到实践笔记——变量和简单数据类型

    Python编程从入门到实践笔记——变量和简单数据类型 #coding=gbk #变量 message_1 = 'aAa fff' message_2 = 'hart' message_3 = &qu ...

  2. Python pandas快速入门

    Python pandas快速入门2017年03月14日 17:17:52 青盏 阅读数:14292 标签: python numpy 数据分析 更多 个人分类: machine learning 来 ...

  3. 懂一点Python系列——快速入门

    本文面相有 一定编程基础 的朋友学习,所以略过了 环境安装.IDE 搭建 等一系列简单繁琐的事情. 一.Python 简介 Python 英文原意为 "蟒蛇",直到 1989 年荷 ...

  4. Python 3 快速入门 2 —— 流程控制与函数

    本文假设你已经有一门面向对象编程语言基础,如Java等,且希望快速了解并使用Python语言.本文对重点语法和数据结构以及用法进行详细说明,同时对一些难以理解的点进行了图解,以便大家快速入门.一些较偏 ...

  5. Python 3 快速入门 3 —— 模块与类

    本文假设你已经有一门面向对象编程语言基础,如Java等,且希望快速了解并使用Python语言.本文对重点语法和数据结构以及用法进行详细说明,同时对一些难以理解的点进行了图解,以便大家快速入门.一些较偏 ...

  6. python语法快速入门(1)

    http://www.runoob.com/python/python-tutorial.html Python 是一种解释型语言: 这意味着开发过程中没有了编译这个环节.类似于PHP和Perl语言 ...

  7. [易学易懂系列|rustlang语言|零基础|快速入门|(6)|变量绑定]

    [易学易懂系列|rustlang语言|零基础|快速入门|(6)] 有意思的基础知识 变量绑定 我们现在回过头来看看,一些基础知识. 因为理解了前面的重要概念:所有权,借用,生命周期. 我们现在看基础知 ...

  8. 转:Python requests 快速入门

    迫不及待了吗?本页内容为如何入门Requests提供了很好的指引.其假设你已经安装了Requests.如果还没有, 去 安装 一节看看吧. 首先,确认一下: ·Requests 已安装 ·Reques ...

  9. 第一阶段——CentOS6_Python3.6.1笔记(尚学堂-Python基础快速入门)+ 【补充】麦子-Python程序入门与进阶

    虚拟机环境: 设置网络 .修改网络地址 .设置网卡为nat模式 .确保物理机启动dhcp.net服务 .编辑文件:vim /etc/sysconfig/network-scripts/ifcfg-et ...

随机推荐

  1. fpic 和 fPIC

    fpic 和 fPIC 区别 Code Gen Options (Using the GNU Compiler Collection (GCC)) 综下所述,生成适用于共享库的位置无关代码(PIC)时 ...

  2. LDAP-初见

    目录 什么是LDAP? LDAP 协议能解决什么问题? Spring Boot中使用LDAP来统一管理用户信息 添加用户 连接LDAP服务端 什么是LDAP? LDAP 的全称是 Lightweigh ...

  3. Mybatis 二级缓存应用 (21)

    [MyBatis 二级缓存] 概述:一级缓存作用域为同一个SqlSession对象,而二级缓存用来解决一级缓存不能夸会话共享,作用范围是namespace级,可以被多个SqlSession共享(只要是 ...

  4. 【UE4 设计模式】策略模式 Strategy Pattern

    概述 描述 策略模式定义了一系列的算法,并将每一个算法封装起来,而且使它们还可以相互替换.策略模式让算法的变化不会影响到使用算法的客户. 套路 Context(环境类) 负责使用算法策略,其中维持了一 ...

  5. 【UE4 插件】UnrealEnginePython 源码版编译、项目打包注意事项

    源码下载 git clone git clone https://github.com/20tab/UnrealEnginePython 直接下载zip https://github.com/20ta ...

  6. 解决git clone慢问题

    解决git clone慢 关于Git克隆或是上传代码龟速的问题真是让人很恼火,这里对于网上的两种解决方案进行摘录. 利用码云克隆github项目 亲测有效 进入码云,新建一个仓库: 在创建的最后选择导 ...

  7. BUAA_2020_软件工程_个人博客作业

    项目 内容 这个作业属于哪个课程 2020春季计算机学院软件工程(罗杰 任健) 这个作业的要求在哪里 个人博客作业 我在这个课程的目标是 了解软件工程的技术,掌握工程化开发的能力 这个作业在哪个具体方 ...

  8. linux系统上国际化失败

    文章目录 一.需求: 二.出现的问题 三.代码结构 1.配置文件中的配置 2.java代码中的使用 四.解决方案 一.需求: 最近项目中有这么一个需求,当用户当前的语言环境是 中文时,导出的 exce ...

  9. MiniFly四轴飞行器之部分系统及电源分析

    最近硬件四轴很火,了解了很久,还是选择了MiniFly,主要还是资料多,后边可以有人讨论,不像很多就是建了个群,研究问题还是在论坛方便很多. 四轴终于拿到手,功能很强大,主要是还支持二次开发,可以研究 ...

  10. mybatis竟然报"Invalid value for getInt()"

    目录 背景 场景 初探 再探 结局 背景 使用mybatis遇到一个非常奇葩的问题,错误如下: Cause: org.apache.ibatis.executor.result.ResultMapEx ...