Python 编程快速上手 - 让繁琐工作自动化第一部分 Python 编程基础

第 1 章 Python 基础

交互式环境：IDLE
提示符：>>>
表达式

数学操作符

操作符	操作	例子	求值为
`**`	指数	`2 ** 3`	8
`%`	取模/取余数	`22 % 8`	6
`//`	整除/商数取整	`22 // 8`	2
`/`	除法	`22 / 8`	2.75
`*`	乘法	`3 * 5`	15
`-`	减法	`5 - 2`	3
`+`	加法	`2 + 2`	4

常见数据类型

数据类型	例子
整型	-2,-1,0,1,2,3,4,5
浮点型	-1.25,-1.0,--0.5,0.0,0.5,1.0,1.25
字符串	'a','aa','aaa','Hello!','11 cats'

字符串连接：'Alice' + 'Bob'
字符串复制：'Alice' * 5
赋值：spam = 40
变量名：

只能是一个词
只能包含字母、数字和下划线
不能以数字开头

python

print('Hello world!')
print('What\'s your name?')
myName = input()
print('It\'s good to meet you, ' + myName)
print('The length of your name is:')
print(len(myName))
print('What\'s your age?')
myAge = input()
print('You will be ' + str(int(myAge) + 1) + ' in a year.')

注释：# This program says hello and asks for my name.
转型：str()、int()、float()

第 2 章控制流

布尔值：True、False

比较操作符：

操作符	含义
`==`	等于
`!=`	不等于
`<`	小于
`>`	大于
`<=`	小于等于
`>=`	大于等于

布尔操作符：and、or、not

代码块规则：

缩进增加时，代码块开始
代码块可以包含其它代码块
缩进减少为零，或减少为外面包围代码块的缩进，代码块就结束了

控制流语句：

if
- if关键字
- 条件
- 冒号
- 在下一行开始，缩进的代码块
python
```
if name == 'Alice':
    print('Hi, Alice.')
```
1
2

else

python

if name == 'Alice':
    print('Hi, Alice.')
else:
    print('Hi, stranger.')

elif

python

if name == 'Alice':
    print('Hi, Alice.')
elif age < 12:
    print('You are not Alice, kiddo.')

while

python

spam = 0
while spam < 5:
    print('Hello, world.')
    spam = spam + 1

break

跳出循环

python

while True:
    print('Please type your name.')
    name = input()
    if name == 'your name':
        break
print('Thank you!')

continue

跳回到循环开始处

python

while True:
    print('Who are you?')
    name = input()
    if name != 'Joe':
        continue
    print('Hello, Joe. What is the password? (It is a fish.)')
    password = input()
    if password == 'swordfish':
        break
print('Access granted.')

for & range()

在用于条件时，0、0.0、''被认为是 False，其它值被认为是 True 。

python

print('My name is')
for i in range(5):
    print('Jimmy Five Times (' + str(i) + ')')

bash

My name is
Jimmy Five Times (0)
Jimmy Five Times (1)
Jimmy Five Times (2)
Jimmy Five Times (3)
Jimmy Five Times (4)

python

for i in range(12, 16):
    print(i)

bash

python

for i in range(0, 10, 2):
    print(i)

bash

导入模块：

python

import random
for i in range(5):
    print(random.randint(1, 10))

导入多个模块：

python

import random, sys, os, math

from import:

类似于 java 中的静态导入，调用方法时不用带前缀。

python

from random import *
for i in range(5):
    print(randint(1, 10))

提前结束程序 sys.exit() ：

python

import sys

while True:
    print('Type exit to exit.')
    response = input()
    if response == 'exit':
        sys.exit()
    print('You typed ' + response + '.')

第 3 章函数

def 语句和参数：

python

def hello(name):
    print('Hello ' + name)

hello('JiaJia')
hello('DT')

返回值和 return 语句

python

import random

def getAnswer(answerNumber):
    if answerNumber == 1:
        return 'It is certain'
    elif answerNumber == 2:
        return 'It is decidedly so'
    elif answerNumber == 3:
        return 'Yes'

r = random.randint(1,3)
fortune = getAnswer(r)
print(fortune)

None 值

None 是 NoneType 数据类型的唯一值。

python

spam = print('Hello')
None == spam

在幕后，对于所有没有 return 语句的函数定义，Python 都会在末尾加上 return None

关键字参数和 print()

关键字参数类似于 C# 中的命名参数。

python

print('Hello')
print('World')

bash

Hello
World

python

print('Hello', end = '')
print('World')

bash

HelloWorld

局部和全局作用域

只有一个全局作用域，它在程序开始时创建。

全局作用域的代码不能使用任何局部变量；
局部作用域可以访问全局变量；
一个函数的局部作用域中的代码，不能使用其它局部作用域中的变量；
如果在不同的作用域中，你可以使用相同的名字命名不同的变量。也就是说，可以有一个名为 spam 的局部变量，和一个名为 spam 的全局变量。

global 语句

如果需要在一个函数内修改全局变量，就是用 global 语句。

python

def spam():
    global eggs
    eggs = 'spam'

eggs = 'global'
spam()
print(eggs) ## spam

有 4 条法则来区分一个变量是出于局部作用域还是全局作用域：

如果变量在全局作用域中使用（即在所有函数之外），它就是全局变量；
如果在一个函数中，有针对该变量的 global 语句，它就是全局变量；
否则，如果该变量用于函数中的赋值语句，它就是局部变量；
但是，如果该变量没有用在赋值语句中，它就是全局变量；

python

def spam():
    global eggs
    eggs = 'spam' # this is the global

def bacon():
    eggs = 'bacon' # this is a local

def ham():
    print(eggs) # this is the global

eggs = 42 # this is the global
spam()
print(eggs) ## spam
bacon()
print(eggs) ## spam
ham() ## spam

在一个函数中，一个变量要么总是全局变量，要么总是局部变量。

异常处理：

错误可以由 try 和 except 语句来处理。

python

def spam(divideBy):
    try:
        return 42 / divideBy
    except ZeroDivisionError:
        print('Error: Invalid argument.')

print(spam(2)) # 21.0
print(spam(12)) # 3.5
print(spam(0)) # Error: Invalid argument.\n None
print(spam(1)) # 42.0

第 4 章列表

列表用左方括号开始，右方括号结束，即 []。

bash

>>> [1,2,3]
[1, 2, 3]
>>> ['cat', 'bat', 'rat', 'elephant']
['cat', 'bat', 'rat', 'elephant']
>>> ['hello', 3.1415, True, None, 42]
['hello', 3.1415, True, None, 42]
>>> spam = ['cat', 'bat', 'rat', 'elephant']
>>> spam
['cat', 'bat', 'rat', 'elephant']

列表中第一个值的下标是 0。

bash

>>> spam[0]
'cat'
>>> spam[1000]
Traceback (most recent call last):
  File "<pyshell#35>", line 1, in <module>
    spam[1000]
IndexError: list index out of range
>>> spam[1.0]
Traceback (most recent call last):
  File "<pyshell#36>", line 1, in <module>
    spam[1.0]
TypeError: list indices must be integers or slices, not float

负数下标：

-1 指的是列表中的最后一个下标；-2 是倒数第二个。

bash

>>> spam[-1]
'elephant'

多重下标：

bash

>>> spam = [['cat', 'bat'], [10, 20, 30, 40, 50]]
>>> spam[0]
['cat', 'bat']
>>> spam[0][1]
'bat'
>>> spam[1][4]
50

切片：

切片向上增长，直至第二个下标的值，但不包括它。
切片求值为一个新的列表值。

python

>>> spam = ['cat', 'bat', 'rat', 'elephant']
>>> spam[0:4]
['cat', 'bat', 'rat', 'elephant']
>>> spam[1:3]
['bat', 'rat']
>>> spam[0:-1]
['cat', 'bat', 'rat']
>>> spam[:2]
['cat', 'bat']
>>> spam[1:]
['bat', 'rat', 'elephant']
>>> spam[:]
['cat', 'bat', 'rat', 'elephant']

用 len() 取得列表的长度

python

>>> len(spam)
4

用下标改变列表中的值：

python

>>> spam[1] = 'aardvark'
>>> spam
['cat', 'aardvark', 'rat', 'elephant']
>>> spam[2] = spam[1]
>>> spam
['cat', 'aardvark', 'aardvark', 'elephant']
>>> spam[-1] = 12345
>>> spam
['cat', 'aardvark', 'aardvark', 12345]

列表连接和列表复制：

+ 操作符可以连接两个列表，得到一个新列表。
* 操作符可以用于一个列表和一个整数，实现列表的复制。

python

>>> [1, 2, 3] + ['A', 'B', 'C']
[1, 2, 3, 'A', 'B', 'C']
>>> ['X', 'Y', 'Z'] * 3
['X', 'Y', 'Z', 'X', 'Y', 'Z', 'X', 'Y', 'Z']
>>> spam = [1, 2, 3]
>>> spam = spam + ['A', 'B', 'C']
>>> spam
[1, 2, 3, 'A', 'B', 'C']

用 del 从列表中删除值：

del 语句将删除列表中下标处的值。

python

>>> spam = ['cat', 'bat', 'rat', 'elephant']
>>> del spam[2]
>>> spam
['cat', 'bat', 'elephant']
>>> del spam[2]
>>> spam
['cat', 'bat']

del 语句也可以用于一个简单变量。

列表：

python

catNames = []
while True:
    print('Enter the name of cat ' + str(len(catNames) + 1) + ' (Or enter nothing to stop.):')
    name = input()
    if name == '':
        break
    catNames = catNames + [name] # list concatenation

print('The cat names are:')
for name in catNames:
    print(' ' + name)

bash

Enter the name of cat 1 (Or enter nothing to stop.):
Zophie
Enter the name of cat 2 (Or enter nothing to stop.):
Pooka
Enter the name of cat 3 (Or enter nothing to stop.):
Simon
Enter the name of cat 4 (Or enter nothing to stop.):
Lady Macbeth
Enter the name of cat 5 (Or enter nothing to stop.):
Fat-tail
Enter the name of cat 6 (Or enter nothing to stop.):
Miss Cleo
Enter the name of cat 7 (Or enter nothing to stop.):

The cat names are:
 Zophie
 Pooka
 Simon
 Lady Macbeth
 Fat-tail
 Miss Cleo

in 和 not in 操作符：

利用 in 和 not in 操作符，可以确定一个值是否在列表中。

python

>>> 'howdy' in ['hello', 'hi', 'howdy', 'heyas']
True
>>> spam = ['hello', 'hi', 'howdy', 'heyas']
>>> 'cat' in spam
False
>>> 'howdy' not in spam
False
>>> 'cat' not in spam
True

方法

方法和函数是一回事，只是它是调用在一个值上。
每种数据类型都有它自己的一组方法。

用 index() 方法在列表中查找值

如果值不在列表中，会报 ValueError 。

python

>>> spam = ['hello', 'hi', 'howdy', 'heyas']
>>> spam.index('hello')
0
>>> spam.index('heyas')
3
>>> spam.index('howdy howdy howdy')
Traceback (most recent call last):
  File "<pyshell#79>", line 1, in <module>
    spam.index('howdy howdy howdy')
ValueError: 'howdy howdy howdy' is not in list

如果列表中存在重复的值，返回它第一次出现的下标。

python

>>> spam = ['Zophie', 'Pooka', 'Fat-tail', 'Pooka']
>>> spam.index('Pooka')
1

用 append() 和 insert() 方法在列表中添加值

将参数添加到列表末尾：

python

spam.append('moose')

insert() 方法的第一个参数是新列表项的下标：

python

>>> spam = ['cat', 'bat', 'rat', 'elephant']
>>> spam.insert(1, 'chicken')
>>> spam
['cat', 'chicken', 'bat', 'rat', 'elephant']

用 remove() 方法从列表中删除值

python

>>> spam = ['cat', 'bat', 'rat', 'elephant']
>>> spam.remove('bat')
>>> spam
['cat', 'rat', 'elephant']

移除不存在的项时会报错：

python

>>> spam.remove('chicken')
Traceback (most recent call last):
  File "<pyshell#91>", line 1, in <module>
    spam.remove('chicken')
ValueError: list.remove(x): x not in list

如果该值在列表中出现多次，只有第一次出现的值会被移除。

用 sort() 方法将列表中的值排序

python

>>> spam = [2, 5, 3.14, 1, -7]
>>> spam.sort()
>>> spam
[-7, 1, 2, 3.14, 5]

逆序排序：

python

>>> spam.sort(reverse=True)
>>> spam
[5, 3.14, 2, 1, -7]

sort() 方法当场对列表排序。不要写成 spam = spam.sort() 这样的代码。
不能对既有数字又有字符串的列表排序。
sort() 方法对字符串排序时，使用“ASCII 字符顺序”（即大写字母排在小写字母之前）。

字符串和元组

对列表的很多操作也可以作用于字符串：按下标取值、切片、用于 for 循环、用于 len() ，以及用于 in 和 not int 操作符。

列表是可变数据类型，但字符串是“不可变的”，它不能被更改。
“改变”一个字符串的正确方式，是使用切片和连接。

python

>>> name = 'Zophie a cat'
>>> newName = name[0:7] + 'the' + name[8:12]
>>> name
'Zophie a cat'
>>> newName
'Zophie the cat'

元组数据类型

“元组”数据类型几乎和数据列表类型一样。

元组输入时用圆括号()，而不是用方括号[]
元组和字符串一样，是不可变的。不可修改、添加或删除。

如果元组中只有一个值，可以在括号内该值的后面跟上一个逗号。

python

>>> type(('hello',))
<class 'tuple'>
>>> type(('hello'))
<class 'str'>

Python 可以实现一些优化，让使用元组的代码比使用列表的代码更快。

用 list() 和 tuple() 函数来转换类型

python

>>> tuple(['cat', 'dot', 5])
('cat', 'dot', 5)
>>> list(('cat', 'dot', 5))
['cat', 'dot', 5]
>>> list('hello')
['h', 'e', 'l', 'l', 'o']

引用

当你将列表赋给一个变量时，实际上是将列表的“引用”赋给了该变量。引用是一个值，指向某些数据。
对于不可变的数据类型的值，例如字符串、整型或元组，Python 变量就保存值本身。

传递引用

当函数被调用时，参数的值被复制给变元。对于列表，这意味着变元得到的是引用的拷贝。

copy 模块的 copy() 和 deepcopy() 函数

python

>>> import copy
>>> spam = ['A', 'B', 'C', 'D']
>>> cheese = copy.copy(spam)
>>> cheese[1] = 42
>>> spam
['A', 'B', 'C', 'D']
>>> cheese
['A', 42, 'C', 'D']

如果要复制的列表中包含了列表，那就是用 copy.deepcopy() 函数来代替。
deepcopy() 函数将同时复制它们内部的列表。

第 5 章字典和结构化数据

python

>>> myCat = { 'size': 'fat', 'color': 'gray', 'disposition': 'loud'}
>>> myCat
{'size': 'fat', 'color': 'gray', 'disposition': 'loud'}
>>> myCat['size']
'fat'

字典中的表项是不排序的。
在字典中，键值对输入的顺序并不重要。

keys()、values()、items() 方法分别对应于字典的键、值和键值对；
这些方法返回的值不是真正的列表，它们不能被修改，但可以用于 for 循环。

python

>>> myCat.keys()
dict_keys(['size', 'color', 'disposition'])
>>> myCat.values()
dict_values(['fat', 'gray', 'loud'])
>>> myCat.items()
dict_items([('size', 'fat'), ('color', 'gray'), ('disposition', 'loud')])

in 和 not in 操作符可以检查值是否存在于列表中。

python

>>> 'size' in myCat.keys()
True
>>> 'fat' in myCat.values()
True

get() 方法：

第二个参数为键值不存在时的默认值。

python

>>> myCat.get('size', 'thin')
'fat'

setdefault() 方法：

第一个参数是键值；
第二个是参数是键值不存在时要设置的值；
返回值是当前的键值。

python

>>> spam = { 'name': 'Pooka', 'age': 5}
>>> spam.setdefault('color', 'black')
'black'
>>> spam
{'name': 'Pooka', 'age': 5, 'color': 'black'}
>>> spam.setdefault('color', 'white')
'black'
>>> spam
{'name': 'Pooka', 'age': 5, 'color': 'black'}

漂亮打印：

python

>>> import pprint
>>> pprint.pprint(spam)
{'age': 5, 'color': 'black', 'name': 'Pooka'}
>>> print(spam)
{'name': 'Pooka', 'age': 5, 'color': 'black'}
>>> print(pprint.pformat(spam))
{'age': 5, 'color': 'black', 'name': 'Pooka'}

第 6 章字符串操作

字符串字面量：'JiaJia'、"JiaJia's blog"、'JiaJia\'s blog'

转义字符：\'、\"、\t、\n、\\

原始字符串：忽略所有的转义字符

python

>>> print(r'JiaJia\'s blog')
JiaJia\'s blog

多行字符串：

三重引号 ‘’‘ 之间的所有引号、制表符或换行，都被认为是字符串的一部分。

python

>>> print('''Dear JiaJia:
...
2022-03-27''')
Dear JiaJia:
...
2022-03-27

多行注释：虽然 # 表示这一行是注释，但多行字符串常常用作多行注释。

字符串像列表一样，使用下标和切片。

python

>>> spam = 'Hello JiaJia'
>>> spam[0:5]
'Hello'
>>> spam[0]
'H'

int 和 not in 操作符也可以用于字符串。

python

>>> 'Hello' in 'Hello JiaJia'
True

有用的字符串方法：

upper()
lower()

python

>>> spam.upper()
'HELLO JIAJIA'
>>> spam.lower()
'hello jiajia'

这些方法并没有改变字符串本身，而是返回一个新的字符串。

isupper()
islower()

如果字符串至少有一个字母，并且所有字母都是大写或小写，isupper() 或 islower() 就会相应的返回 True 。

python

>>> spam = 'Hello JiaJia'
>>> spam.isupper()
False
>>> spam.islower()
False
>>> 'HELLO'.isupper()
True
>>> 'hello'.islower()
True
>>> 'abc12345'.islower()
True
>>> '12345'.islower()
False
>>> '12345'.isupper()
False

isalpha()：字符串只包含字母，并且非空；
isalnum()：字符串只包含字母和数字，并且非空；
isdecimal()：字符串只包含数字字符，并且非空；
isspace()：字符串只包含空格，制表符和换行，并且非空；
istitle()：字符串仅包含大写字母开头、后面都是小写字母的单词。

python

>>> 'hello'.isalpha()
True
>>> 'hello123'.isalpha()
False
>>> 'hello123'.isalnum()
True
>>> 'hello'.isalnum()
True
>>> '123'.isdecimal()
True
>>> ' '.isspace()
True
>>> 'This Is Title Case'.istitle()
True
>>> 'This Is Title Case 123'.istitle()
True
>>> 'This Is not Title Case'.istitle()
False
>>> 'This Is NOT Title Case Either'.istitle()
False

startswith()
endswith()

以传入的字符串开始或结束。

python

>>> 'Hello JiaJia!'.startswith('Hello')
True
>>> 'Hello JiaJia!'.endswith('JiaJia!')
True

join()
split()

python

>>> ', '.join(['cats', 'rats', 'bats'])
'cats, rats, bats'
>>> 'My name is jiajia'.split(' ')
['My', 'name', 'is', 'jiajia']

rjust()
ljust()
center()

返回字符串的填充版本，通过插入空格来对齐文本。

python

>>> 'Hello'.rjust(10)
'     Hello'
>>> 'Hello'.rjust(20)
'               Hello'
>>> 'Hello World'.rjust(20)
'         Hello World'
>>> 'Hello'.ljust(10)
'Hello     '
>>> 'Hello'.rjust(20, '*')
'***************Hello'
>>> 'Hello'.rjust(20, '-')
'---------------Hello'
>>> 'Hello'.center(20)
'       Hello        '
>>> 'Hello'.center(20, '=')
'=======Hello========'

strip()
rstrip()
lstrip()

删除空白字符

python

>>> ' Hello World '.strip()
'Hello World'
>>> ' Hello World '.rstrip()
' Hello World'
>>> ' Hello World '.lstrip()
'Hello World '

用 pyperclip 模块拷贝粘贴字符串

bash

pip3 install pyperclip

python

>>> import pyperclip
>>> pyperclip.copy('Hello world!')
>>> pyperclip.paste()
'Hello world!'

Python 编程快速上手 - 让繁琐工作自动化 第一部分 Python 编程基础 ​

第 1 章 Python 基础 ​

第 2 章 控制流 ​

第 3 章 函数 ​

第 4 章 列表 ​

第 5 章 字典和结构化数据 ​

第 6 章 字符串操作 ​

Python 编程快速上手 - 让繁琐工作自动化第一部分 Python 编程基础

第 1 章 Python 基础

第 2 章控制流

第 3 章函数

第 4 章列表

第 5 章字典和结构化数据

第 6 章字符串操作