0%

Python - Theme 1 Basic

Posted on In Views: Valine:
Symbols count in article: 10k Reading time ≈ 9 mins.

0. 介绍

Python版本: 3.X

  • Python是一门高级计算机编程语言，简单易用。
  • Python的哲学就是 简单优雅。Python为我们提供了非常完善的基础代码库，例如：网络、文件、GUI、数据库等大量内容，而且还有极其丰富的第三方库，使用极其方便、不用重复造轮子。国内外许多大型网站都是用Python写的，比如YouTube、Instagram、豆瓣等等，Google也在大量的使用此语言。

0.1. 适用场景

  • 网站后台
  • 网络应用
  • 自动化工具
  • 科学计算(人工智能)
  • 把其他语言包装起来(胶水语言)

0.2. 不适用场景

  • 操作系统
  • 移动应用
  • 3D游戏开发

0.3. 缺点

  • 解释型语言，相对较慢(C语言)
  • 没法加密(源码)

一、Python基础

1. 输入与输出(IO)

1
2
3
4
5
6
7
PyDev console: starting.
Python 3.6.3 (default, Nov 24 2017, 21:27:36)
[GCC 4.2.1 Compatible Apple LLVM 9.0.0 (clang-900.0.38)] on darwin
>>> name = input('Please enter your name:')
>>> Please enter your name:>? Aaron
>>> print('Hello', name)
Hello Aaron

2. Python编写规范

Python使用 缩进 来组织代码块的，一般约定俗成 4个空格。大小写敏感，**#** 为注释。

1
2
3
4
5
a = 6
if a < 0:
    print(-a)
else:
    print(a)

3. 数据类型和变量

计算机不止能处理数据，还能处理文本、音频、视频、图形等等，因此产生了不同的数据类型。

(1).整数

Python中的整数没有大小限制

1
2
>>> print(-1,0,1,100,0x1f)
-1 0 1 100 31

(2).浮点数

浮点数就是小数，之所以称为浮点数是因为在科学计数法的情况下，可以随意的变动小数点的位置从而改变指数。整数运算是精确的，而浮点数运算是不精确的(四舍五入)。浮点数也没有大小限制，但是超过一定的大小就会inf(无限大)。

1
2
3
4
>>> print(1.23,10**2,10e1,10e2,1.2e-2)
1.23 100 100.0 1000.0 0.012
>>> print(1e1000)
inf

(3).字符串

注意单引号、双引号、转义号

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
>>>print('abc')
abc
>>>print("abc")
abc
>>>print('ab\nc')
ab
c
>>>print('I\'m \"ok\" \'!\'')
I'm "ok" '!'
>>>print('a\\b')
a\b
>>>print(r'a\\b')
a\\b
>>>print('''line1
line2
line3''')
line1
line2
line3

(4).布尔值

与(and) 或(or) 非(not)运算

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
>>>True
True
>>>False
False
>>>3 > 2
True
>>>3 < 2
False
>>>not 3 > 2
False
>>>not 3 < 2
True
>>>True or False
True
>>>True and False
False

(5).空值

0 是有意义的，None 是一个特殊的空值

1
2
3
4
>>>print(None)
None
>>>print(0)
0

(6).变量

Python是 动态语言，使用变量前无需声明变量类型。而Java是静态语言，需要提前声明。

1
2
3
4
5
>>>a = 'ABC'
>>>b = a
>>>a = 'XYZ'
>>>print(b)
ABC

(7).常量

用全部 大写的变量名表示常量 是一个惯用的手法。**”//“ 地板除** 永远是整数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
>>>PI = 3.1415926
>>>9 / 3
3.0
>>>9 // 3
3
>>>9 % 3
0
>>>10 / 3
3.3333333333333335
>>>10 // 3
3
>>>11 // 3
3
>>>10 % 3
1

4. 字符串和编码

计算机是美国🇺🇸发明的，因此最开始的ASCII码只有127个字符字母被编辑到计算机内(大小写字母、标点符号等)。后来各个国家也加入了自己语言的相应编码，例如：中国(GB2312)、日本(Shift_JIS)等，这样一来各个国家的编码会出现不可避免的冲突，在一些有各个国家语言的文本里，就会出现乱码显示。
因此Unicode油然而生，他将所有的语言都统一到了一种编码方式中。ASCII编码常用1个字节，Unicode常用2个字节。这样新的问题就诞生了，如果全是英文的文本中，文本所占用的空间就会比原本的多两倍。因此后来又诞生了可变长度的：UTF-8。
计算机系统通用的字符编码方式：在计算机内存中，使用Unicode的编码方式，在保存到硬盘或者传输的过程中，使用UTF-8。
UTF-8 的一个缺点：计算字符串长度和查找子字符串非常没效率。

  • 使用记事本：用记事本编辑的时候，从文件读取的UTF-8字符被转换为Unicode字符到内存里，编辑完成后，保存的时候再把Unicode转换为UTF-8保存到文件。
  • 浏览网页：服务器会把动态生成的Unicode内容转换为UTF-8再传输到浏览器。网页的源码上会有类似的信息，表示该网页正是用的UTF-8编码。

(1). Python的字符串

Python3.X版本中，字符串是以Unicode编码的，既支持多语言的。

1
2
>>> print('包含中文的str')
包含中文的str

  • 字符串对应编码值转换

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    >>> ord('A')  ##获取字符的整数表示
    65
    >>> ord('中')
    20013
    >>> chr(65)  ##把编码转换成对应的字符
    'A'
    >>> chr(20013)
    '中'
    >>> '\u4e2d' ##如果知道16进制可直接表示
    '中'

  • Python字符串类型str在内存中是以Unicode的形式表示，一个字符对应若干字节，如果在网络传输或者磁盘存储，就要转换成字节为单位bytes。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    >>> b'ABC'
    b'ABC'
    >>> 'ABC'.encode('ascii')
    b'ABC'
    >>> 'ABC'.encode('utf-8')
    b'ABC'
    >>> '中文'.encode('utf-8')
    b'\xe4\xb8\xad\xe6\x96\x87'
    >>> '中文'.encode('ascii')  ##超出了ASCII的范围
    Traceback (most recent call last):
      File "<input>", line 1, in <module>
    UnicodeEncodeError: 'ascii' codec can't encode characters in position 0-1: ordinal not in range(128)

    >>> b'ABC'.decode('ascii')
    'ABC'
    >>> b'\xe4\xb8\xad\xe6\x96\x87'.decode('utf-8')
    '中文'

    >>> b'\xe4\xb8\xad\xff'.decode('utf-8')  ##包含无法解码的字节
    Traceback (most recent call last):
      File "<input>", line 1, in <module>
    UnicodeDecodeError: 'utf-8' codec can't decode byte 0xff in position 3: invalid start byte

    >>> b'\xe4\xb8\xff'.decode('utf-8')
    Traceback (most recent call last):
      File "<input>", line 1, in <module>
    UnicodeDecodeError: 'utf-8' codec can't decode bytes in position 0-1: invalid continuation byte

    >>> b'\xe4\xb8\xad\xe6\x96'.decode('utf-8')
    Traceback (most recent call last):
      File "<input>", line 1, in <module>
    UnicodeDecodeError: 'utf-8' codec can't decode bytes in position 3-4: unexpected end of data

    >>> b'\xe4\xb8\xad\xff'.decode('utf-8',errors='ignore') ##忽略无法解码的字节
    '中'

  • 计算str包含多少字符：1个中文一般占3个字节，一个英文占1个字节

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    >>> len('ABC')
    3
    >>> len('中文')
    2
    >>> len(b'ABC')
    3
    >>> len(b'中文')
      File "<input>", line 1
    SyntaxError: bytes can only contain ASCII literal characters.

    >>> len(b'\xe4\xb8\xad\xe6\x96\x87')
    6
    >>> len('中文'.encode('utf-8'))
    6
    >>> len('ABC'.encode('utf-8'))
    3

  • Python解释器读取源码时，为了让他以UTF-8的编码方式读取

    1
    # -*- coding: utf-8 -*-

  • 输出格式化

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    >>> 'Hello,%s' % 'world'
    'Hello,world'
    >>> 'Hello,%s. Are you %d?' % ('world',18)
    'Hello,world. Are you 18?'

    >>> print('%5d-%05d' % (3, 1))  ##指定整数和浮点数的位数
        3-00001
    >>> print('%.2f' % 3.1415926)
    3.14

    >>> 'Age: %s. Gender: %s' % (18, 'Male')  ##%s比较通用
    'Age: 18. Gender: Male'
    >>> 'growth rate: %d %%' % 100  ##%%表示一个百分号
    'growth rate: 100 %'

    >>> 'Hello, {0}, 成绩提升了 {1:.1f}%'.format('小明', 99.125)  ##format()函数，不常用
    'Hello, 小明, 成绩提升了 99.1%'
占位符 替换内容
%d 整数
%f 浮点数
%s 字符串
%x 十六进制

(2). list和tuple

  • 列表，list是一种 有序集合，可以随时添加\删除其中的元素。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    >>> nameList = ['Tom','Bob','Mary','Jone']
    >>> nameList
    ['Tom', 'Bob', 'Mary', 'Jone']
    >>> len(nameList)
    4
    >>> nameList[0]
    'Tom'
    >>> nameList[1]
    'Bob'
    >>> nameList[4]
    Traceback (most recent call last):
      File "<input>", line 1, in <module>
    IndexError: list index out of range

    >>> nameList[-1]
    'Jone'
    >>> nameList[-4]
    >>> 'Tom'
    nameList[-5]
    Traceback (most recent call last):
      File "<input>", line 1, in <module>
    IndexError: list index out of range

    >>> nameList
    ['Tom', 'Bob', 'Mary', 'Jone']
    >>> nameList.append('Jack') ##添加
    >>> nameList
    ['Tom', 'Bob', 'Mary', 'Jone', 'Jack']
    >>> nameList.pop()  ##弹出
    'Jack'
    >>> nameList
    ['Tom', 'Bob', 'Mary', 'Jone']
    >>> nameList.insert(2,'Jack')  ##插入
    >>> nameList
    ['Tom', 'Bob', 'Jack', 'Mary', 'Jone']
    >>> nameList.pop(2)
    'Jack'

    >>> L = []  ##空列表
    >>> L
    []
    >>> len(L)
    0

    >>> L = [123,'abc',True,[1,2]]  ##列表可以由多种数据类型组成
    >>> L
    >>> [123, 'abc', True, [1, 2]]
    len(L)
    4

  • 元组，有序列表，类似于list，但是其中的元素一经设定将不能修改(既 “指向不变“)。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    >>> t = ()  ##空元组
    >>> t
    ()
    >>> t = (1,)  ##单个元素的元组
    >>> t
    (1,)
    >>> t = ('a','b',['A','B'])  ##嵌套列表的元组
    >>> t
    ('a', 'b', ['A', 'B'])
    >>> t[2][0] = 'X'
    >>> t[2][1] = 'Y'
    >>> t
    ('a', 'b', ['X', 'Y'])

(3). 条件判断

计算机之所以可以做许多的自动化任务是因为其可以做条件判断(从上往下判断)。

1
2
3
4
5
6
7
8
age = input('please input your age: ')
age = int(age)
if age > 18:
    print('adult')
elif age > 6:
    print('teenager')
else:
    print('child')

(4). 循环

循环是让计算机重复做某事的最有效的方式。不要滥用break\continue，会产生太多分叉。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
## for循环
for i in range(101):  ##range函数能生成一个整数序列
    if i % 2 != 0:
        print(i)

## while循环
i = 1
while i <= 100:
    if i % 2 != 0:
        print(i)
    i = i + 1

## continue
i = 0
while i < 100:
    i = i + 1
    if i % 2 == 0:
        continue  ##跳出本轮循环执行下一轮
    print(i)

## break
i = 0
while i < 100:
    if i > 10:
        break  ##满足条件跳出整个循环
    print(i)
    i = i + 1

(5). dict和set

Python内置了字典：dict，其他语言称map，key—value，具有极快的查找速度。通过 Hash算法 查找key对应的value。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
>>> d =  {'Bob':'66','Tom':'77','Kate':'88','Aaron':'99'}
>>> d['Aaron'] ##查找对应Value
'99'
>>> d['Aaron'] = 100  ##重新赋值value
>>> d
{'Bob': '66', 'Tom': '77', 'Kate': '88', 'Aaron': 100}
>>> d['haha']  ##不存在的Key
Traceback (most recent call last):
  File "<input>", line 1, in <module>
KeyError: 'haha'

>>> 'haha' in d  ##判断是否存在Key
False
>>> d.get('haha')
##控制台不显示 None
>>> d.get('haha',-1)  ##不存在key的情况下自定义返回值
-1
>>> d.pop('Bob') ##弹出一对k-v
'66'
>>> d
{'Tom': '77', 'Kate': '88', 'Aaron': 100}

  • dict VS list (空间换时间)

    • dict查找和插入的速度极快，且不会随着key的增加而变慢。list相反。
    • dict需要占用大量内存，而list不会。

  • dict的key必须是不可变对象。str是不可变对象，而list是可变对象。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    >>> l = ['c','b','a']
    >>> l.sort()
    >>> l  ##列表本身发生了变化
    ['a', 'b', 'c']

    >>> s = 'abc'
    >>> s1 = s.replace('a','A')
    >>> s  ##字符串本身没有发生变化
    'abc'
    >>> s1
    'Abc'

  • set和dict类似，也是一组key的集合，但是不存value，因此set中没有重复的值。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    >>> s = set([1,2,2,3])  ##通过list作为输入集合，重复值被过滤
    >>> s
    {1, 2, 3}
    >>> s.add(5)  ##添加元素
    >>> s
    {1, 2, 3, 5}
    >>> s.remove(3)  ##删除元素
    >>> s
    {1, 2, 5}

    >>> s1 = set([1,2,3])
    >>> s2 = set([2,3,4])
    >>> s1 & s2  ##集合可以做数学中的逻辑运算
    {2, 3}
    >>> s1 | s2
    {1, 2, 3, 4}