python基础语法

太过爱你忘了你带给我的痛 2022-09-25 05:12 182阅读 0赞

python基础语法，主要基于2.7，对于3.0的改动有部分指出

链接：[几分钟快速入门Python - 简书][Python -]

**本文主要包括以下内容**

1.  输入输出
2.  数据类型与变量
3.  字符串与编码
4.  list与tuple
5.  循环
6.  dict与set

### python基础语法 ###

**输入输出**

用print()在括号中加上字符串，就可以向屏幕上输出指定的文字。比如输出'hello, world'，用代码实现如下：
    >>> print('hello, world')
    print()函数也可以接受多个字符串，用逗号“,”隔开，就可以连成一串输出：
    
    >>> print('The quick brown fox', 'jumps over', 'the lazy dog')
    The quick brown fox jumps over the lazy dog
    print()会依次打印每个字符串，遇到逗号“,”会输出一个空格

**输入**

现在，你已经可以用print()输出你想要的结果了。但是，如果要让用户从电脑输入一些字符怎么办？Python提供了一个input()，可以让用户输入字符串，并存放到一个变量里。比如输入用户的名字：
    
    >>> name = input()
    Michael
    当你输入name = input()并按下回车后，Python交互式命令行就在等待你的输入了。这时，你可以输入任意字符，然后按回车后完成输入。
    
    输入完成后，不会有任何提示，Python交互式命令行又回到>>>状态了。那我们刚才输入的内容到哪去了？答案是存放到name变量里了。可以直接输入name查看变量内容：
    
    >>> name
    'Michael'

#### 数据类型和变量 ####

**布尔值**

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

>>> True
    True
    >>> False
    False
    >>> 3 > 2
    True
    >>> 3 > 5
    False

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

and运算是与运算，只有所有都为True，and运算结果才是True：

**空值**

空值是Python里一个特殊的值，用None表示。None不能理解为0，因为0是有意义的，而None是一个特殊的空值。

此外，Python还提供了列表、字典等多种数据类型，还允许创建自定义数据类型，我们后面会继续讲到。

**变量**

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

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

**常量**

所谓常量就是不能变的变量，比如常用的数学常数π就是一个常量。在Python中，通常用全部大写的变量名表示常量

最后解释一下整数的除法为什么也是精确的。在Python中，有两种除法，一种除法是/：
    
    >>> 10 / 3
    3.3333333333333335
    /除法计算结果是浮点数，即使是两个整数恰好整除，结果也是浮点数：
    
    >>> 9 / 3
    3.0
    还有一种除法是//，称为地板除，两个整数的除法仍然是整数：
    
    >>> 10 // 3
    3
    你没有看错，整数的地板除//永远是整数，即使除不尽。要做精确的除法，使用/就可以。
    
    因为//除法只取结果的整数部分，所以Python还提供一个余数运算，可以得到两个整数相除的余数：
    
    >>> 10 % 3
    1
    无论整数做//除法还是取余数，结果永远是整数，所以，整数运算结果永远是精确的。

#### 字符串与编码 ####

在最新的Python 3版本中，字符串是以Unicode编码的，也就是说，Python的字符串支持多语言，例如：
    
    >>> print('包含中文的str')
    包含中文的str
    对于单个字符的编码，Python提供了ord()函数获取字符的整数表示，chr()函数把编码转换为对应的字符：
    
    >>> ord('A')
    65
    >>> ord('中')
    20013
    >>> chr(66)
    'B'
    >>> chr(25991)
    '文'
    如果知道字符的整数编码，还可以用十六进制这么写str：
    
    >>> '\u4e2d\u6587'
    '中文'
    两种写法完全是等价的。
    
    由于Python的字符串类型是str，在内存中以Unicode表示，一个字符对应若干个字节。如果要在网络上传输，或者保存到磁盘上，就需要把str变为以字节为单位的bytes。
    
    Python对bytes类型的数据用带b前缀的单引号或双引号表示：
    
    x = b'ABC'
    要注意区分'ABC'和b'ABC'，前者是str，后者虽然内容显示得和前者一样，但bytes的每个字符都只占用一个字节。
    
    以Unicode表示的str通过encode()方法可以编码为指定的bytes，例如：
    
    >>> 'ABC'.encode('ascii')
    b'ABC'
    >>> '中文'.encode('utf-8')
    b'\xe4\xb8\xad\xe6\x96\x87'
    >>> '中文'.encode('ascii')
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    UnicodeEncodeError: 'ascii' codec can't encode characters in position 0-1: ordinal not in range(128)
    纯英文的str可以用ASCII编码为bytes，内容是一样的，含有中文的str可以用UTF-8编码为bytes。含有中文的str无法用ASCII编码，因为中文编码的范围超过了ASCII编码的范围，Python会报错。
    
    在bytes中，无法显示为ASCII字符的字节，用\x##显示。
    
    反过来，如果我们从网络或磁盘上读取了字节流，那么读到的数据就是bytes。要把bytes变为str，就需要用decode()方法：
    
    >>> b'ABC'.decode('ascii')
    'ABC'
    >>> b'\xe4\xb8\xad\xe6\x96\x87'.decode('utf-8')
    '中文'
    要计算str包含多少个字符，可以用len()函数：
    
    >>> len('ABC')
    3
    >>> len('中文')
    2
    len()函数计算的是str的字符数，如果换成bytes，len()函数就计算字节数：
    
    >>> len(b'ABC')
    3
    >>> len(b'\xe4\xb8\xad\xe6\x96\x87')
    6
    >>> len('中文'.encode('utf-8'))
    6
    可见，1个中文字符经过UTF-8编码后通常会占用3个字节，而1个英文字符只占用1个字节。
    
    在操作字符串时，我们经常遇到str和bytes的互相转换。为了避免乱码问题，应当始终坚持使用UTF-8编码对str和bytes进行转换。
    
    由于Python源代码也是一个文本文件，所以，当你的源代码中包含中文的时候，在保存源代码时，就需要务必指定保存为UTF-8编码。当Python解释器读取源代码时，为了让它按UTF-8编码读取，我们通常在文件开头写上这两行：
    
    #!/usr/bin/env python3
    # -*- coding: utf-8 -*-
    第一行注释是为了告诉Linux/OS X系统，这是一个Python可执行程序，Windows系统会忽略这个注释；
    
    第二行注释是为了告诉Python解释器，按照UTF-8编码读取源代码，否则，你在源代码中写的中文输出可能会有乱码。
    
    申明了UTF-8编码并不意味着你的.py文件就是UTF-8编码的，必须并且要确保文本编辑器正在使用UTF-8 without BOM编码：

#### 使用list和tuple ####

**list**

Python内置的一种数据类型是列表：list。list是一种有序的集合，可以随时添加和删除其中的元素。

比如，列出班里所有同学的名字，就可以用一个list表示：  
变量classmates就是一个list。用len()函数可以获得list元素的个数：  
用索引来访问list中每一个位置的元素，记得索引是从0开始的：  
当索引超出了范围时，Python会报一个IndexError错误，所以，要确保索引不要越界，记得最后一个元素的索引是len(classmates) - 1。

如果要取最后一个元素，除了计算索引位置外，还可以用-1做索引，直接获取最后一个元素：

list是一个可变的有序表，所以，可以往list中追加元素到末尾：
    
    >>> classmates.append('Adam')
    >>> classmates
    ['Michael', 'Bob', 'Tracy', 'Adam']
    也可以把元素插入到指定的位置，比如索引号为1的位置：
    
    >>> classmates.insert(1, 'Jack')
    >>> classmates
    ['Michael', 'Jack', 'Bob', 'Tracy', 'Adam']
    要删除list末尾的元素，用pop()方法：
    
    >>> classmates.pop()
    'Adam'
    >>> classmates
    ['Michael', 'Jack', 'Bob', 'Tracy']
    要删除指定位置的元素，用pop(i)方法，其中i是索引位置：
    
    >>> classmates.pop(1)
    'Jack'
    >>> classmates
    ['Michael', 'Bob', 'Tracy']
    要把某个元素替换成别的元素，可以直接赋值给对应的索引位置：
    
    >>> classmates[1] = 'Sarah'
    >>> classmates
    ['Michael', 'Sarah', 'Tracy']
    list里面的元素的数据类型也可以不同，比如：
    
    >>> L = ['Apple', 123, True]
    list元素也可以是另一个list，比如：
    
    >>> s = ['python', 'java', ['asp', 'php'], 'scheme']
    >>> len(s)
    4
    要注意s只有4个元素，其中s[2]又是一个list，如果拆开写就更容易理解了：
    
    >>> p = ['asp', 'php']
    >>> s = ['python', 'java', p, 'scheme']
    要拿到'php'可以写p[1]或者s[2][1]，因此s可以看成是一个二维数组，类似的还有三维、四维……数组，不过很少用到。
    
    如果一个list中一个元素也没有，就是一个空的list，它的长度为0：
    
    >>> L = []
    >>> len(L)
    0

**tuple**  
另一种有序列表叫元组：tuple。tuple和list非常类似，但是tuple一旦初始化就不能修改，比如同样是列出同学的名字：

>>> classmates = ('Michael', 'Bob', 'Tracy')                    
    现在，classmates这个tuple不能变了，它也没有append()，insert()                           这样的方法。其他获取元素的方法和list是一样的，你可以正常地使用classmates[0]，classmates[-1]，但不能赋值成另外的元素。                      
    
    不可变的tuple有什么意义？因为tuple不可变，所以代码更安全。如果可能，能用tuple代替list就尽量用tuple。
    
    tuple的陷阱：当你定义一个tuple时，在定义的时候，tuple的元素就必须被确定下来，比如：
    
    
    但是，要定义一个只有1个元素的tuple，如果你这么定义：
    
    >>> t = (1)
    >>> t
    1
    定义的不是tuple，是1这个数！这是因为括号()既可以表示tuple，又可以表示数学公式中的小括号，这就产生了歧义，因此，Python规定，这种情况下，按小括号进行计算，计算结果自然是1。
    
    所以，只有1个元素的tuple定义时必须加一个逗号,，来消除歧义：
    
    >>> t = (1,)
    >>> t
    (1,)
    Python在显示只有1个元素的tuple时，也会加一个逗号,，以免你误解成数学计算意义上的括号。

#### 循环 ####

Python的循环有两种，一种是for…in循环，依次把list或tuple中的每个元素迭代出来，看例子：

names = ['Michael', 'Bob', 'Tracy']
    for name in names:
        print(name)
    所以for x in ...循环就是把每个元素代入变量x，然后执行缩进块的语句。
    
    再比如我们想计算1-10的整数之和，可以用一个sum变量做累加：
    
    sum = 0
    for x in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]:
        sum = sum + x
    print(sum)
    如果要计算1-100的整数之和，从1写到100有点困难，幸好Python提供一个range()函数，可以生成一个整数序列，再通过list()函数可以转换为list。比如range(5)生成的序列是从0开始小于5的整数：
    
    >>> list(range(5))
    [0, 1, 2, 3, 4]
    range(101)就可以生成0-100的整数序列，计算如下：
    
    sum = 0
    for x in range(101):
        sum = sum + x
    print(sum)
    请自行运行上述代码，看看结果是不是当年高斯同学心算出的5050。
    
    第二种循环是while循环，只要条件满足，就不断循环，条件不满足时退出循环。比如我们要计算100以内所有奇数之和，可以用while循环实现：
    
    sum = 0
    n = 99
    while n > 0:
        sum = sum + n
        n = n - 2
    print(sum)
    在循环内部变量n不断自减，直到变为-1时，不再满足while条件，循环退出。

#### 使用dict和set ####

**dict**

用dict实现，只需要一个“名字”-“成绩”的对照表，直接根据名字查找成绩，无论这个表有多大，查找速度都不会变慢。用Python写一个dict如下：
    
    >>> d = {
       'Michael': 95, 'Bob': 75, 'Tracy': 85}
    >>> d['Michael']
    95

**set**

set和dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key。

要创建一个set，需要提供一个list作为输入集合：

>>> s = set([1, 2, 3])
    >>> s
    {1, 2, 3}
    注意，传入的参数[1, 2, 3]是一个list，而显示的{1, 2, 3}只是告诉你这个set内部有1，2，3这3个元素，显示的顺序也不表示set是有序的。。
    
    重复元素在set中自动被过滤：
    
    >>> s = set([1, 1, 2, 2, 3, 3])
    >>> s
    {1, 2, 3}
    通过add(key)方法可以添加元素到set中，可以重复添加，但不会有效果：
    
    >>> s.add(4)
    >>> s
    {1, 2, 3, 4}
    >>> s.add(4)
    >>> s
    {1, 2, 3, 4}
    通过remove(key)方法可以删除元素：
    
    >>> s.remove(4)
    >>> s
    {1, 2, 3}
    set可以看成数学意义上的无序和无重复元素的集合，因此，两个set可以做数学意义上的交集、并集等操作：
    
    >>> s1 = set([1, 2, 3])
    >>> s2 = set([2, 3, 4])
    >>> s1 & s2
    {2, 3}
    >>> s1 | s2
    {1, 2, 3, 4}

[Python -]: http://www.jianshu.com/p/a155eb855e18/comments/3411556#comment-3411556