1. Python基础语法

Python中变量的命名规则：

• 变量名的第一个字符不能是数字

赋值

Python允许你同时为多个变量赋值 ， 也可以为多个对象指定多个变量。

Python中对变量没有显式的类型定义，但是在使用一个变量前，必须先对其进行赋值，通过赋值完成变量的定义。从本质上讲，Python中由值的特征决定了空间分配和解析方式，变量只是对值的所在空间的引用。简而言之，Python是以值为中心的。

值为一个对象，为值分配空间，变量只是引用。

2. Python基本数据类型：

Python中提供了6种基本数据类型，None表示空对象，无类型。

2.1 数字

Python3 支持 int、float、bool（布尔）、complex（复数） 4种数字类型。布尔类型只有True和False两个值。

Python中：没有数值范围的限制。

 #type()函数用于获取变量的类型

Python中的数值运算基本与c相同，增加了整除(//)和幂(**)两种运算。

4.3 - 2 # => 2.3
3 * 7 # => 21
2 / 4 # => 0.5 除法，得到一个浮点数
2 // 4 # => 0 整数除法，得到一个整数
17 % 3 # => 2 取余
2 ** 5 # => 32 乘方

2.2 字符串（String）

字符串的创建和基本运算

字符串间可以通过 + 号进行连接

"Hello " + "world!" => "Hello world!"

可以通过 * 号，对字符串进行复制，比如：

"Hello" * 3 => "HelloHelloHello"

Python的字符串有两种索引方式，第一是从左往右，从0开始依次增加，第二种是从右往左，从-1开始依次减少。

Python没有单独的字符类型，一个字符就是长度为1的字符串。

可以对字符串进行切片，获取一段子串冒号分隔两个索引：

变量[头下标:尾下标:步长]

两个索引都可以省略。

字符串的切片是原字符串的副本，对切片的修改不影响原字符串

s = 'ILovePython'
s[1:10:2] # => 'LvPto'
s[:] # => 'ILovePython'
s[5:] # => 'Python'
s[-10:-6] # => 'Love'

采用函数len()获取字符串的长度

len()方法同样可以用于其他数据类型，例如查看列表、元组以及字典中元素的多少。

2.2.1 关于字母的内置函数

2.2.2 关于判断的内置函数

isalnum() 字符串中只有字母或数字
isalpha() 检测字符串是否只由字母组成
isdigit() 字符串是否只由数字组成
islower() 检测字符串是否由小写字母组成
isspace() 字符串是否只由空白字符组成
istitle() 检测字符串中所有的单词拼写首字母是否为大写，且其他字母为小写。
isupper() 字符串中所有的字母是否都为大写

2.2.3 常用功能

1.replace(old, new[, max]) old – 将被替换的子字符串。new – 新字符串，用于替换old子字符串。max – 可选字符串, 替换不超过 max 次 |把字符串中的 old（旧字符串） 替换成 new(新字符串)，如果指定第三个参数max，则替换不超过 max 次
2.join(sequence) sequence – 要连接的元素序列。用于将序列中的元素以指定的字符连接生成一个新的字符串。

     1.str = "-";
     2.seq = ("a", "b", "c"); # 字符串序列
     3.print str.join( seq );
     4.a-b-c

3.split(str=””, num=string.count(str)) |1.str – 分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等。2.num – 分割次数。默认为 -1, 即分隔所有。通过指定分隔符对字符串进行切片，如果第二个参数 num 有指定值，则分割为 num+1 个子字符串。
4.count(sub, start= 0,end=len(string)) |sub – 搜索的子字符串start – 字符串开始搜索的位置。默认为第一个字符,第一个字符索引值为0。end – 字符串中结束搜索的位置。字符中第一个字符的索引为 0。默认为字符串的最后一个位置。|用于统计字符串里某个字符出现的次数。可选参数为在字符串搜索的开始与结束位置。

2.2.4 位置对齐

2.2.5 检查查找

2.2.6 删除空白符

2.3 列表（List）

List（列表） 是 Python 中使用最频繁的数据类型，可以实现大多数集合类的数据结构。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（即嵌套列表）。列表是写在方括号[]之间、用逗号分隔开的元素列表。

和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表（副本），使用语法形式与字符串完全相同。

tinylist = [123, 'upc']

print(list) # => ['abcd', 786, 2.23, 'upc', 70.2] 输出完整列表
print(list[0]) # => abcd 输出列表第一个元素
print(list[1:3]) # => [786, 2.23] 从第二个开始输出到第三个元素
print(list[2:]) # => [2.23, 'upc', 70.2] 输出从第三个元素开始的所有元素
print(tinylist * 2) # => [123, 'upc', 123, 'runoob'] 输出两次列表
print(list + tinylist) # => ['abcd', 786, 2.23, 'upc', 70.2, 123, 'upc'] 连接列表

与Python字符串不一样的是，列表中的元素是可以改变的：

a = [1, 2, 3, 4, 5, 6]
a[0] = 9
a[2:5] = [13, 14, 15]
print(a) => [9, 2, 13, 14, 15, 6]
a[2:5] = [] 将对应的元素值设置为 []
print(a) => [9, 2, 6]
a.append(7)
print(a) => [9, 2, 6, 7]
b=a.pop()
print(b) => 7
print(a) => [9, 2, 6]

以下是列表的常用函数，函数定义中的方括号表示这个参数是可选的。

a = [66.25, 333, 333, 1, 1234.5]
print(a.count(333), a.count(66.25), a.count('x')) # => 2 1 0
a.insert(2, -1)
a.append(333)
print(a) # => [66.25, 333, -1, 333, 1, 1234.5, 333]
print(a.index(333)) # => 1
a.remove(333)
print(a) # => [66.25, -1, 333, 1, 1234.5, 333]
a.reverse()
print(a) # => [333, 1234.5, 1, 333, -1, 66.25]
a.sort()
print(a) # => [-1, 1, 66.25, 333, 333, 1234.5]
a = [9, 2, 6]
a.append([1, 2, 3]) #append the new list as one element
print(a) # => [9, 2, 6, [1, 2, 3]]
a = [9, 2, 6]
a.extend([1, 2, 3]) #append each element in the new list
print(a) # => [9, 2, 6, 1, 2, 3]

在一个列表中添加另外一个列表时，注意extend() 和append() 两个函数的异同点

通过空格将字符串分隔符，把各个单词分隔为列表，split的参数表示分隔的字符

inputWords = input.split(" ")
print(inputWords) # => ['I', 'like', 'upc']

inputWords[::-1] 有三个参数

前两个参数为空，表示取列表中的所有元素

第三个参数为步长，-1 表示逆向

inputWords=inputWords[::-1]
print(inputWords) # => ['upc', 'like', 'I']

重新组合字符串，在几个字符串之间用空格进行连接

output = ' '.join(inputWords) #join函数只能将多个字符串进行连接
print(output) # => upc like I
</pre>

通过split()函数将字符串分隔成一个列表，然后可以用个join()函数将列表中每个字符串进行拼接。

split(str=””, num=string.count(str))函数原型中有两个参数，str表示分隔符，num表示分割次数。默认为 -1, 即分隔所有。

2.4 元组（Tuple）

元组（Tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号 () 里，元素之间用逗号隔开。元组中的元素类型也可以不相同， 可以把字符串看作一种特殊的元组。

虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表。

构造包含 0 个或 1 个元素的元组比较特殊，所以有一些额外的语法规则：

tup0 = () # 空元组
tup1 = (20,) # 一个元素，需要在元素后添加逗号

在Python中很多地方使用隐式元组，它使Python更具有灵活性。例如

a, b, c = 1, 2, "upc"

可以理解为

(a, b, c) = (1, 2, "upc")

即两个元组的对应元素逐个赋值

在C语言中，很多地方都规定必须唯一，比如：赋值号的左侧只能有一个变量，函数的返回值只能有一个值，Python借助隐式元组完美的解决了这些问题。

利用隐式元组，可以非常简单的实现两个变量的值交换。

a,b=3,5 #多变量赋值
a,b=b,a #交换a和b的值
print(a,b) # => 5 3

2.5 集合（Set）

集合（set）是由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员。基本功能是进行成员关系测试和删除重复元素。可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

student = {'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'}

输出集合，重复的元素被自动去掉

print(student) # => {'Mary', 'Jim', 'Rose', 'Jack', 'Tom'}

成员测试

if 'Rose' in student :
print('Rose 在集合中') # => Rose 在集合中
else :
print('Rose 不在集合中')

set可以进行集合运算

a = set('abracadabra')
b = set('alacazam')

print(a) # => {'b', 'a', 'c', 'r', 'd'}

a 和 b 的差集

print(a - b) # => {'b', 'd', 'r'}

a 和 b 的并集

print(a | b) # => {'l', 'r', 'a', 'c', 'z', 'm', 'b', 'd'}

a 和 b 的交集

print(a & b) # => {'a', 'c'}

a 和 b 中不同时存在的元素

print(a ^ b) # => {'l', 'r', 'z', 'm', 'b', 'd'}

集合中的元素是无序的，注意以上例子中，输入的集合和输出的集合顺序是不一致的。

集合(set)常用来抽取一系列元素中的唯一值。但因为集合是无序的，不能保证元素顺序的不变性。
适用于可变集合set和不可变集合frozenset的函数(方法)：

集合类型的通用函数(方法)
函数（方法） 描述
s.copy() 复制集合s
a.difference(b,c,d...) 求差集
a.intersection(b,c,d...) 求交集
s.isdisjoint(b) 判断集合s和集合b有没有相同项(元素)
a.issubset(b) 判断集合a是否是集合b的子集
a.issuperset(b) 判断集合a是否是集合b的超集
a.symmetric_difference(b) 求对称差集
a.union(b,c,d...) 求并集
len(s) 求集合s中项(元素)的数量

仅适用于可变集合的函数(方法)：
可变集合函数（方法）用法
函数(方法) 描述
s.add(x) 将x添加到集合s中
s.clear() 删除集合s中所有元素(项)
s.discard(value) 从集合s中删除元素value
s.remove(value) 从集合s中删除元素value
s.pop() 返回集合s中任意一个元素，并将其删除
s.difference_update(x) 从集合s中删除同时也在x中出现的所有元素
s.update(x) 将x中的所有元素添加到集合s中
s.symmetric_difference_update(x) 计算集合s与x的对称差集，并将结果保存在集合s中
s.intersection_update(x) 计算集合s与x的交集，并将结果保存在集合s中

2.6 字典（Dictionary）

字典（dictionary）是Python中另一个非常有用的内置数据类型。列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合。键(key)必须使用不可变类型，而且在同一个字典中，键(key)必须是唯一的。

aDict = {}
aDict['one'] = "中国石油大学"
aDict[2]     = "智能科学系"
tinydict = {'name': 'upc','code':1, 'site': 'www.upc.edu.cn'}#典型的键和值组成的集合
 
print(aDict['one'])    # => 中国石油大学        输出键为 'one' 的值
print(aDict[2])        # => 智能科学系          输出键为 2 的值
print(tinydict)        # => {'name': 'upc', 'code': 1, 'site': 'www.upc.edu.cn'}
print(tinydict.keys())   # => dict_keys(['name', 'code', 'site'])  
print(list(tinydict.keys()))    # => ['name', 'code', 'site']   将键值集合转换为列表
print(tinydict.values()) # => dict_values(['upc', 1, 'www.upc.edu.cn']) 
print(list(tinydict.values()))  # => ['upc', 1, 'www.upc.edu.cn'] 将值集合转换为列表

Attention 字典的键就是一个集合(set)，因此也是无序的

2.7 类型转换

Python中采用函数进行类型转换：

3. 数据的输入和输出

3.1 输入

input([prompt]) 函数用来从标准输入读取一行文本。prompt 表示输入提示，可省略。input() 函数将一个回车之前的内容全部读入，返回值是文本类型。

s = input("Please input: ");        # => Please input：中国石油大学
print ("The content is: ", s)       # => The content is: 中国石油大学

当输入内容是一个非字符串类型时，需要进行强制类型转换

num = int(input())   #if the input is 56 and you wanna get an integer
print(num)      # => 56
print(type(num))    # => <class 'int'>

当输入是多个相同类型的变量时，可以采用map()函数进行批量转换。map(function, iterable, ...)函数的第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。

s = input()   #if the input is '3.4, 5.6, 8.7' and you wanna get 3 float number
numLst = s.split(',')       # split 's' to a list with seperator ','
#make a list of return values of function 'float' for each element in 'numLst'
resultLst = map(float,numLst)    
a,b,c = resultLst   #set a,b,c with 3 elements in list 'resultLst'
print(a,b,c)  # => 3.4 5.6 8.7
print(type(a),type(b),type(c))  # => <class 'float'> <class 'float'> <class 'float'>

变量s 把'3.4, 5.6, 8.7'作为一个字符串接收，通过split函数，以逗号为分隔符，形成了一个列表numLst，然后其中的每一个元素受函数float的作用，将返回值形成了一个新列表resultLst，resultLst中的每一个元素都是float类型，最后将列表中的三个元素对应赋值给变量a,b,c。可以将以上代码简化为一条语句：

a,b,c = map(float,input().split(','))   #if the input is “3.4, 5.6, 8.7” 
print(a,b,c)  # => 3.4 5.6 8.7

3.2 输出

3.2.1 print的参数

print函数可以添加参数sep和end，sep表示输出多个对象时的分隔符号，默认为空格，end表示结束符号，默认为回车。

print(1,2,3)    # => 1 2 3
print(1,2,3,sep=',')    # => 1,2,3 逗号作为分隔符
#左对齐，居中对齐，右对齐
print(str(1).ljust(3),'|',str(2).center(3),'|',str(3).rjust(3),'|',sep='')
#=>1  | 2 |  3|
print(str(12).zfill(5))     # => 00012     左侧补0

3.2.2 字符串格式化

Python用 str.format() 函数进行输出的格式化

#大括号及其里面的字符 (称作格式化字段) 将会被 format() 中的参数替换。
print('{}网址： {}'.format('中国石油大学', 'www.upc.edu.cn'))
# => 中国石油大学网址： www.upc.edu.cn

#在大括号中的数字用于指向传入对象在 format() 中的位置
print('{0} {1}'.format('intelligence', 'technology'))
# => intelligence technology
print('{1} {0}'.format('intelligence', 'technology'))
# => technology intelligence

#如果在 format() 中使用了关键字参数, 那么它们的值会指向使用该名字的参数
print('{name}网址： {site}'.format(name='中国石油大学', site='www.upc.edu.cn'))
# => 中国石油大学网址： www.upc.edu.cn

#位置及关键字参数可以任意的结合
print('{0} {1} {dept}'.format('intelligence', 'technology', dept='department'))
# => intelligence technology department

3.2.3 f-string格式化

从Python 3.6开始，提供了一种f-string的输出方法，是当前最佳的拼接字符串的形式，拥有更强大的功能，使输出更加简洁。它的基本语法格式为：

f'<text> {<expression>[:format specifier]} <text> ...'

<text>指一些文本内容，experession是Python变量或表达式，format specifier指格式控制。格式控制可以省略，其中的d或f参数分别指十进制和浮点数，具体用法与C语言相同。

name='ben'
age=30
sex='male'
mm,dd=7,3
job='IT'
salary=12000

print(f'My name is {name.capitalize()}.')  # => My name is Ben.
print(f'I am {age:*^10} years old.')  # => I am ****30**** years old.
print(f'I am a {sex}.')  # => I am a male.
print(f'My birthday is {mm:02d}/{dd:02d}.')  # => My birthday is 07/03.
print(f'My salary is ${salary:10.2f}.')  # => My salary is $  12000.00.
print(f'The result is {dd*5+2}.')  # => The result is 17.

从执行时间角度，f-string是目前效率最高的字符串拼接方法。