Python 是什么

Python 的本质，在于它只是一个工具，工具虽然强大，但更强大的的是会使用用工具来达到事半功备的人。

起步-认识和使用 Python - 图1

Python是一种面向对象的解释型计算机程序设计语言，由荷兰人 Guido van Rossum （龟叔）于 1989 年发明。第一个公开发行版发行于1991年。

起步-认识和使用 Python - 图2

从百科上可以看出，龟叔是专业的，从事的也是计算机相关的工作，在圣诞节为了打发时间，创造出了 Python，可见牛人总是相似的。

发展到今天，Python 已经是一种功能非常强大的高级编程语言，其他高级语言能实现的功能，Python 都能方便快捷地实现。

Python 的设计哲学

Python 的设计哲学是“优雅”、“明确”、“简单”。它的重要准则被称为“Python之禅”。在 Python 解释器内运行 import this 可以获得完整的列表，下面是其中首要：

优美胜于丑陋，明晰胜于隐晦
简单胜于复杂，复杂胜于繁芜
扁平胜于嵌套，稀疏胜于密集
可读性很重要。

Python能做什么

其实，应该问，Python 不能做什么，因为 Python 能做的事情实在太多了。有个段子是这样说的，除了生孩子不会，其他都可以。虽然有点跨张，却从侧面说明 Python 的应用领域非常广泛。
从人工智能、Web 开发、自动化运维、数据分析都有广泛的应用。而自动化办公只是一个小小的应用场景。

以下各大主流网站就是用 Python 来驱动的：

起步-认识和使用 Python - 图3

Python基础必备

安装 Python

Python3 最新源码，二进制文档，新闻资讯等可以在 Python 的官网查看到：

Python 官网：https://www.python.org/

从这里下载对应操作系统的安装文件，双击安装即可。

你可以在以下链接中下载 Python 的文档，你可以下载 HTML、PDF 和 PostScript 等格式的文档。

Python文档地址：https://www.python.org/doc/

认识关键字

  1. import keyword
  2. print(keyword.kwlist)

数据类型和变量

计算机顾名思义就是可以做数学计算的机器，因此，计算机程序理所当然地可以处理各种数值。

但是，计算机能处理的远不止数值，还可以处理文本、图形、音频、视频、网页等各种各样的数据，不同的数据，需要定义不同的数据类型。

在 Python 中，能够直接处理的数据类型有以下几种：

整数与浮点数

编程是将问题数据化的一个过程，数据离不开数字，Python的数字运算规则和我们在小学初中学习的四则运算规则是一样的，即使不使用Python来编写复杂的程序，也可以把它当作一个强大的计算器。

打开 Python，试运行以下命令：

  1. >>> 2 + 2
  2. 4
  3. >>> 50 - 5*6
  4. 20
  5. >>> (50 - 5*6) / 4
  6. 5.0
  7. >>> 8 / 5  # 总是返回一个浮点数
  8. 1.6

注意：在不同的机器上浮点运算的结果可能会不一样。

在整数除法中，除法（/）总是返回一个浮点数，如果只想得到整数的结果，可以使用运算符 // 。

整数除法返回浮点型，整数和浮点数的混合运算的结果也是浮点型：

  2. >>> 19 / 3  # 整数除法返回浮点型
  3. 6.333333333333333
  4. >>>
  5. >>> 19 // 3  # 整数除法返回向下取整后的结果
  6. 6
  7. >>> 17 % 3  # ％操作符返回除法的余数
  8. 1
  9. >>> 5 * 3 + 2.0 
  10. 17.0

Python 可以使用 ** 操作来进行幂运算：

  2. >>> 5 ** 2  # 5 的平方
  3. 25
  4. >>> 2 ** 7  # 2的7次方
  5. 128

在交互模式中，最后被输出的表达式结果被赋值给变量 _ ，这能使我们后续计算更方便，例如：

  2. >>> tax = 12.5 / 100
  3. >>> price = 100.50
  4. >>> price * tax
  5. 12.5625
  6. >>> price + _
  7. 113.0625
  8. >>> round(_, 2)
  9. 113.06

Python 数字类型转换：

  • int(x) 将x转换为一个整数。
  • float(x) 将x转换到一个浮点数。
  • complex(x) 将x转换到一个复数，实数部分为 x，虚数部分为 0。
  • complex(x, y) 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式。

常用的数学函数参见表 1-2。

起步-认识和使用 Python - 图4

字符串

1. 认识简单字符串

Python中的字符串有几种表达方式，可以使用单引号、双引号或三引号（三个单引号或三个双引号）括起来，如下：

  1. >>> 'abc'
  2. 'abc'
  3. >>> "abc"
  4. 'abc'
  5. >>> '''a\
  6. ... b\
  7. ... c'''  #使用 反斜线（\） 来续行
  8. 'abc'
  9. >>> '''abc'''
  10. 'abc'

如果想在字符串含有单引号、双引号该怎么处理呢？有两种方法：一是使用反斜杠转义引号；二是使用与字符串中单引号、双引号不同的引号来定义字符串，如：

  1. >>> a='a\'b\'c'#定义字符串a，使用反斜杠转义单引号
  2. >>> print(a)#打印字符串a
  3. a'b'c
  4. >>> b="a'b'c"#定义字符串b，使用双引号括起含有单引号的字符串
  5. >>> print(b) #打印字符串b
  6. a'b'c

使用\n换行或者使用三引号如：

  1. >>> s = 'First line.\nSecond line.'  # \n 意味着新行
  2. >>> print(s)
  3. First line.
  4. Second line.
  5. >>> s='''First line.
  6. ... Second line'''#字符串可以被 """ （三个双引号）或者 ''' （三个单引号）括起来。使用三引号时，换行符不需要转义，它们会包含在字符串中。
  7. >>> print(s)
  8. First line.
  9. Second line

如果需要避免转义，我们可以使用原始字符串，即在字符串的前面加上’r’。如：

  1. >>> s = r"This is a rather long string containing\n\
  2. ... several lines of text much as you would do in C."
  3. >>> print(s)
  4. This is a rather long string containing\n\
  5. several lines of text much as you would do in C.

字符串可以使用 + 运算符串连接在一起，或者用 * 运算符重复字符串：

  1. >>> word = 'Help' + ' '+ 'ME'
  2. >>> print(word)
  3. Help ME
  4. >>> word="word "*5
  5. >>> print(word)
  6. word word word word word

2. 字符串的索引

字符串可以被索引，就像 C 语言中的数组一样，字符串的第一个字符的索引为 0，一个字符就是长度为一的字符串。

就像 Icon 编程语言一样，子字符串可以使用分切符来指定：用冒号分隔的两个索引，第一个索引默认为 0，第二个索引默认为最后一个位置，

比如 s[:] 表示整个字符串，s[2:3] 表示从第 3 个字符开始，到第 4 个字符结束，不含第4个字符。

  1. >>> s="abcdefg"
  2. >>> s[0]
  3. 'a'
  4. >>> s[1]
  5. 'b'
  6. >>> s[:]#表示整个字符串
  7. 'abcdefg'
  8. >>> s[2:3]
  9. 'c'
  10. >>> s[2:]
  11. 'cdefg'
  12. >>> s[-1]
  13. 'g'
  14. >>> s[-2:]
  15. 'fg'
  16. >>> s[0]='f'#向一个索引位置赋值会导致错误，说明字符串是只读的
  17. Traceback (most recent call last):
  18.   File "<stdin>", line 1, in <module>
  19. TypeError: 'str' object does not support item assignment

3. 字符串的遍历

遍历字符串有三种方式：一是使用 enumerate 函数，其返回字符串的索引及相应的字符，二是直接使用 for 循环，三是通过字符索引来遍历，如下：

  1. >>> for i,a in enumerate(s):
  2. ...     print(i,a)
  3. ...
  4. 0 a
  5. 1 b
  6. 2 c
  7. 3 d
  8. 4 e
  9. 5 f
  10. 6 g
  11. >>> for a in s:
  12. ...     print(a)
  13. ...
  14. a
  15. b
  16. c
  17. d
  18. e
  19. f
  20. g
  21. >>> for i in range(len(s)):
  22. ...     print(i,s[i])
  23. ...
  24. 0 a
  25. 1 b
  26. 2 c
  27. 3 d
  28. 4 e
  29. 5 f
  30. 6 g

有一个方法可以帮我们记住分切索引的工作方式，想像索引是指向字符之间，第一个字符左边的数字是 0。接着，有n个字符的字符串最后一个字符的右边是索引n，例如：

字符串 a b c d e f g
索引1 0 1 2 3 4 5 6
索引2 -7 -6 -5 -4 -3 -2 -1

如 s[1:3] 代表’bc’, s[-2:-1] 代表 ’f’。

4. 字符串的格式化

Python 支持格式化字符串的输出。尽管这样可能会用到非常复杂的表达式，但最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。

  1. >>> print ("我叫 %s 今年 %d 岁!" % ('小明', 10))#使用%
  2. 我叫 小明 今年 10 岁!
  3. >>> print ("我叫 {} 今年 {} 岁!" .format('小明', 10))#使用字符串的format方法
  4. 我叫 小明 今年 10 岁!
  5. >>> print ("我叫 {0} 今年 {1} 岁!" .format('小明', 10,20))#使用索引，整数20未用到
  6. 我叫 小明 今年 10 岁!

布尔值

布尔值和布尔代数的表示完全一致，一个布尔值只有 True、False 两种值，要么是 True，要么是 False。
在 Python 中，可以直接用 True、False 表示布尔值（请注意大小写），也可以通过布尔运算计算出来：

  1. >>> True
  2. True
  3. >>> False
  4. False
  5. >>> 3 > 2
  6. True
  7. >>> 3 > 5
  8. False

布尔值可以用 and、or 和 not 运算。

and 运算是与运算，只有所有都为True，and 运算结果才是 True，or 运算是或运算，只要其中有一个为True，or 运算结果就是 True：

  1. >>> True and True
  2. True
  3. >>> True and False
  4. False
  5. >>> False and False
  6. False
  7. >>> 5 > 3 and 3 > 1
  8. True
  9. >>> True or True
  10. True
  11. >>> True or False
  12. True
  13. >>> False or False
  14. False
  15. >>> 5 > 3 or 1 > 3
  16. True
  17. >>> not True
  18. False
  19. >>> not False
  20. True
  21. >>> not 1 > 2
  22. True

变量

变量的概念基本上和初中代数的方程变量是一致的，只是在计算机程序中，变量不仅可以是数字，还可以是任意数据类型。

变量在程序中就是用一个变量名表示，变量名必须是大小写英文、数字和_的组合，且不能用数字开头，比如：

  1. a = 1
  2. t_007 = 'T007'

练习题

在交互式环境中打印以下变量，看看输出的结果是否符合预期

  1. # -*- coding: utf-8 -*-
  2. n = 123
  3. f = 456.789
  4. s1 = 'Hello, world'
  5. s2 = 'Hello, \'Adam\''
  6. s3 = r'Hello, "Bart"'
  7. s4 = r'''Hello,
  8. Lisa!'''

使用容器

列表与元组

列表是 Python 最常用的数据类型，也是最基本的数据结构。Python 的列表是由方括号‘[]’括起，使用‘,’分隔的序列，序列中的数据类型不要求一致，序列的索引从 0 开始。
【示例1-1】创建一个列表。只要把逗号分隔的不同的数据项使用方括号括起来即可，如下：

  1. >>> list1 = ['Google', 'Huawei', 1997, 2000];
  2. >>> list2 = [1, 2, 3, 4, 5 ];
  3. >>> list3 = ["a", "b", "c", "d"];
  4. >>> list4=["all of them",list1,list2,list3]
  5. >>> print ("list1[0]: ", list1[0])
  6. list1[0]:  Google
  7. >>> print ("list2[1:5]: ", list2[1:5])
  8. list2[1:5]:  [2, 3, 4, 5]
  9. >>> print(list4)
  10. ['all of them', ['Google', 'Huawei', 1997, 2000], [1, 2, 3, 4, 5], ['a', 'b', 'c', 'd']]
  11. >>> print(list4[1][1])
  12. Huawei

【示例1-2】更新一个列表。可以对列表的数据项进行修改或更新，也可以使用append()方法来添加列表项，如下：

  1. >>> list = ['Google', 'Huawei', 1997, 2000]
  2. >>> print ("第三个元素为 : ", list[2])
  3. 第三个元素为 :  1997
  4. >>> list[2] = 2001
  5. >>> print ("更新后的第三个元素为 : ", list[2])
  6. 更新后的第三个元素为 :  2001
  7. >>> list.append('xiaomi')
  8. >>> print ("追加后的最后一个元素为 : ", list[-1])
  9. 追加后的最后一个元素为 :  xiaomi
  10. >>> list.insert(2,'qq')
  11. >>> print ("在第3个位置上插入的元素为 : ", list[2])
  12. 在第3个位置上插入的元素为 :  qq

【示例1-3】删除列表中的某个元素，如下：

  1. >>> list = ['Google', 'Huawei', 1997, 2000]
  2. >>> del list[0]
  3. >>> print(list)
  4. ['Huawei', 1997, 2000]
  5. 列表还有一些其他操作，如列表对 + 和 * 的操作符与字符串相似，+ 号用于组合列表，* 号用于重复列表，如下：
  6. >>> len([1, 2, 3])                        #获取列表元素个数len()
  7. 3
  8. >>> [1, 2, 3] + [4, 5, 6]                    #+用于组合列表
  9. [1, 2, 3, 4, 5, 6]
  10. >>> ['Hi!'] * 10                            # *用于重复列表
  11. ['Hi!', 'Hi!', 'Hi!', 'Hi!', 'Hi!', 'Hi!', 'Hi!', 'Hi!', 'Hi!', 'Hi!']
  12. >>> 3 in [1, 2, 3]                         #判断元素是否在列表中
  13. True
  14. >>> for x in [1, 2, 3]: print(x, end=" ")         #遍历列表元素
  15. ...
  16. 1 2 3 >>> max([1,2,3])                    #返回列表最大值
  17. 3
  18. >>> min([1,2,3])                        #返回列表最小值
  19. 1

元组是不可变的列表，这里的不可变指的是元组中的元素的指向永远不变。

元组与列表类似，用“()”括起，“,”分隔的序列，不同与列表的是，元组是只读的，无法被修改，元组在定义时其元素必须确定下来，元组也可以像列表一样使用索引来访问。

  1. >>> t = ('Google', 'Huawei', 1997, 2000)    #定义一个元组
  2. >>> t[0]                            #使用和列表一样的方式访问相应元素
  3. 'Google'
  4. >>> t[-1]
  5. 2000
  6. >>> t[0]='Baidu'                        #修改元组的值将会抛出异常
  7. Traceback (most recent call last):
  8.   File "<stdin>", line 1, in <module>
  9. TypeError: 'tuple' object does not support item assignment
  10. >>> t=()                            #定义一个空的元组
  11. >>> t
  12. ()
  13. >>> type(t)
  14. <class 'tuple'>
  15. >>> t=(1,)                            #定义一个只有一个元素的元组，“,”是元组的特征
  16. >>> （1）==1                        # 注意（1）等于1，不是元组
  17. True

dict 字典

提到字典，我们会想到中华字典、英语词典，通过给定的单词（key），查找其含义（value）。在字典里，要查找的单词（key）在字典里是唯一的，但不同的单词其含义（value）可能相同。

Python里的字典就是键值对组成的集合，且可存储任意类型对象。

定义一个字典非常简单：使用一对花括号 {} 括起，键值对之间使用“,”分隔。如：

>>> dict = { 'hello':'你好','world':'世界',} #定义一个字典dict
>>> dict
{'hello': '你好', 'world': '世界'}
>>> dict['hello']
'你好'
>>> len(dict)  #计算字典元素个数，即键的总数。
2
>>>str(dict)   #输出字典，以可打印的字符串表示。
"{'hello': '你好', 'world': '世界'}"

字典值可以是任何的 Python 对象，既可以是标准的对象，也可以是用户自定义的，但键不行。两个重要的点需要记住：

（1）不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住。

【示例1-6】如下：
>>> dict = { 'hello':'你好','world':'世界','hello':'world'} #键hello的值被更新为world
>>> dict
{'hello': 'world', 'world': '世界'}

（2）键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行。即：键必须为不可变数据类型。

>>> d = { 'a':1,'b':2, ['a']:'abc'}                 #键是列表，会报错
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

遍历字典:



>>> d = { 'a':1, 'b':2, 'c':3, 'd':4, 'e':5, 'f':6 }         #定义一个字典
>>> for key,value in d.items():      #d.items()方法返回一个键值对的元组（key,value）
...     print(key,value)
...
a 1
b 2
c 3
d 4
e 5
f 6
>>> for key in d:                        #以键来取值
...     print(key,d[key])               #python强制缩进，与上一行比有4个空格
...
a 1
b 2
c 3
d 4
e 5
f 6
>>>

修改字典：

>>> d = { 'a':1, 'b':2, 'c':3, 'd':4, 'e':5, 'f':6 }
>>> d['b']='b'
>>> d
{'a': 1, 'b': 'b', 'c': 3, 'd': 4, 'e': 5, 'f': 6}

删除字典元素。可以删除单一的元素，也可以一次性删除所有元素，清空字典，显式地删除一个字典用 del 命令，如下：

>>> del d['b']   #删除键b
>>> d           #删除键b后
{'a': 1, 'c': 3, 'd': 4, 'e': 5, 'f': 6}
>>> d.clear()  #清空字典 
>>> d
{}
>>> del d        #删除字典
>>> d            #删除字典后，字典d已不存在
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'd' is not defined

set 集合

集合 set 是一个无序不重复元素集，基本功能包括关系测试和消除重复元素。

集合对象还支持 union（联合）、intersection（交）、difference（差）和 sysmmetric difference（对称差集）等数学运算。

在 Python 中可以使用 ”x in set” 来判断 x 是否在集合中，使用 ”len(set)” 来获取集合元素个数。

使用”for x in set”来遍历集合中的元素。但由于集合不记录元素位置，因此集合不支持获取元素位置和切片等操作。

集合的定义和常见用法：


>>> x=set('abcd')               #创建集合x由单个字符组成
>>> y=set(['a','bc','d',10])      #创建集合y，由列表的元素组成
>>> x,y                     #打印x,y
({'a', 'b', 'd', 'c'}, {'a', 'd', 10, 'bc'})
>>> x & y                   #取交集 
{'a', 'd'}
>>> x|y                     #取并集
{'c', 'bc', 'd', 10, 'b', 'a'}
>>> x-y                     #差集，表示x里有，y里没有的
{'b', 'c'}
>>> x^y                        #对称差集（项在x或y中，但不会同时出现在二者中）
{'bc', 'c', 10, 'b'}

使用集去重元素。

>>> a = [11,22,33,44,11,22]
>>> b = set(a)
>>> b
set([33, 11, 44, 22])

条件判断

if语句的一般形式如下：


if 条件1：
    语句1
elif 条件2：
    语句2
else:
    语句3

解释：如果条件 1 为真，则执行语句 1，如果条件 1 不为真，条件 2 为真，执行语句 2，如果条件 1、条件 2 都不为真，执行语句 3。

其中 elif 和 else 语句不是必须的。

循环语句

while 循环

for 循环

练习题：打印 99 乘法表。

for x in range(1, 10):  # x是乘数
    for y in range(1, x + 1):  # 主是被乘数
        result = f"{x * y}".rjust(2)
        print(f"{y}x{x}={result}".ljust(8), end = '')  # 使用新特性格式化字符串，也可以使用format,%等格式化，其中ljust（6）左对齐，长度为6，右补空格
    print("")  # 打印一个换行

使用函数

在中学数学中我们知道y=f(x)代表着函数，x是自变量，y是函数f(x)的值。在程序中， 自变量x可以代表任意的数据类型，可以是字符串、列表、字典、对象，可以是我们认为的任何东西。

以简单的数据计算函数为例，定义函数fun(a,b,h)来计算上底为a，下底为b，高为h的梯形的面积：


>>> def fun(a,b,h):      #def 定义函数fun，参数为a，b，h
...     s=(a+b)*h/2     #使用梯形的面积计算公式，注意此行前有4个空格
...     return s         #返回面积
...
>>> fun(3,4,5)         #计算上底为3，下底为4，高为5的梯形的面积
17.5

函数的目的是封装，提高应用的模块性，和代码的重复利用率。将常用的处理过程写成函数，在需要的时候调用它，可以屏蔽实现细节，减少代码量，增加程序可读性。

使用类

class Person(object):

    def __init__(self, name, sex):
        self.name = name
        self.sex = sex

    def walk(self):
        print(f"{self.name} is walking...")

    def __str__(self):
        return self.name

编写一个 Student 类，继承 Person：


class Student(Person):

    def __init__(self, name,sex, score):
        super().__init__(name,sex)
        self.score = score

    def learning(self):
        print(f"{self.name} is learning...")

    def __str__(self):
        return f"{self.name}, {self.score}"

读写文件

写入并读取文件：

with open("test.txt","w") as writer:
    for i in range(10):
        writer.write(f"Python 基础 {i} \n")

with open("test.txt", "r") as reader:
    for line in reader:
        print(line.strip())