python初阶---基础语法篇(二)

一、数据类型

1、逻辑型
逻辑型又称布尔型，取值只有两种：0和1，或者真和假（False和True）。其中，False和True是0和1的另一种表达形式。他们可以直接参与运算。

True + 100
False + 100

2、数值型
数值型包括整数和浮点数。数值型运算符有：加(+)、减(-)、乘(*)、除(/)。
3、字符型
字符型数据一般用单引号(’ ')或双引号(“ ”)包起来，如果字符串中包含特殊字符，则用反斜杠 \ 转义特殊字符。
对字符串可以进行切片操作。

string = 'ABCDEFGHIJK'
#无步长的切片方式，其语法为string[star:stop]
string[0]   #取索引序号为0的字符串，得到单个字符‘A’
string[0:2] #获取字符串中索引从0开始到2结束的位置的所有字符串（不包括2），切片得到字符串'AB'
'''注：当不指定start时，默认从索引0开始，当不指定stop时，
默认取到最后一个元素，当start和stop都不指定，则获取的是整个字符串'''
#带步长的切片方式，其语法为string[start:stop:strip]
string[0:8:2] #切片得到字符串‘ACEG’

'''注：字符串的索引序号是从0开始的,按[star:stop]进行切片操作是左闭右开的，
因此string[0:2]取的是字符串string中位置索引序号0和1的字符'''

此外，还可以对字符串使用一些函数来进行操作，对字符串操作常用函数：

注：string.split(’ sep’,int)和string.rsplit(‘sep ‘,int)在不指定int值时，其效果无区别。指定int值时，string.split(’ sep’,int)是将字符串string按分隔符sep从左到右分割int次，string.rsplit('sep ',int)是将字符串string按分隔符sep从右到左分割int次(所有符号都算是分隔符，包括空格)。

二、列表

1、列表简介
list（列表）是Python中一种非常重要的数据类型。列表中可以包含多个元素，且元素类型可以不相同。每一元素可以是任意一种数据类型，包括列表（即列表的嵌套）、元组、字典、集合。所有元素都包含在一对方括号“[]”中，每两个元素之间用逗号分隔。对于不包含任何元素的列表，即“[]”，称为空列表。
2、列表索引
要获取列表的元素，可以使用list[index]的方式，其中，index是要访问的元素的索引。要获取列表的子列表，可以使用list[beg:end]的方式，其中，beg是要取出的部分元素在list中的起始索引，end是要取出的部分元素在list中的结束索引。

ls = [1,2,3,4,5]  #定义列表ls
ls[3]    #获取列表中索引为3的元素
ls[0:3]  #获取列表中索引从0开始到3结束的所有元素（不包括3），得到子列表[1,2,3]
ls[:3]   #等价于ls[0:3] 
ls[2:]   #表示取出从索引为2的位置开始直到最后一个元素（包括最后一个元素）
ls[:]    #beg和end都省略，表示取出ls中的所有元素

注：Python中，第一个列表元素的索引为0，而不是1。
3、列表常用函数

三、元组

1、元组简介
Tuple（元组）与列表类似，可以包含多个元素，且元素类型可以不相同，书写时每两个元素之间也是用逗号分隔。与列表不同的是，元组的所有元素都写在一对小括号“()”中，且元组中的元素不能修改。对于不包含任何元素的元组，即()，称为空元组。
二、元组的索引
元组的索引方式与列表的索引方式完全相同。可以使用tuple[index]访问元组中的元素，也可以使用tuple[beg:end]的方式取出元组中的部分元素形成一个新元组。

x = (1,2,3,4,5)  #定义元组x方式一
x = 1,2,3 ,4,5   #定义元组x方式二
x[1] #获取元组x中索引为1的元素
x[0:3] #获取元组中索引从0开始到3结束的元素(不包括2)，形成一个新的元组
x[:3] #等价于x[0:3]
x[2:] #表示取出从索引为2的位置开始直到最后一个元素（包括最后一个元素）
x[:]  #beg和end都省略，表示取出x中的所有元素

在Python中，如果多个变量用半角逗号隔开，则默认将多个变量按tuple的形式组织起来，因此在Python中两个变量的互换可以这样写：

x,y = 1,2 #将1赋给x，将2赋给y
x,y = y,x #将x和y的值互换

3、元组常用函数

四、集合

一、集合简介
与元组和列表类似，set（集合）中同样可以包含多个不同类型的元素，但集合中的各个元素无序，不允许有相同元素且元素必须是可哈希的对象。可哈希对象是指拥有__hash__(self)内置函数的对象。列表、元组、集合和字典类型的数据不是可哈希对象，所以它们不能作为集合中的元素。
注：（1）set中的元素位置是无序的，因此不能用set[i]这样的方式获取其元素。
（2）set中不能保存重复数据，即具有过滤重复数据的功能。
二、集合创建
集合中的所有元素都写在一对大括号“{}”中，各元素之间用逗号分隔。创建集合时，既可以使用{}，也可以使用set函数，set函数的语法格式为：set(iterable)。其中，iterable是一个可选参数，表示一个可迭代对象。
注：可迭代（iterable）对象是指可以一次返回它的一个元素，如字符串、列表、元组都是可迭代的数据类型。

>>> s1 = set("abcdefg")   #创建集合s1
>>> s2 = set("defghijkl") #创建集合s2
>>> s1
{'d', 'e', 'b', 'c', 'f', 'a', 'g'}
>>> s2
{'l', 'd', 'k', 'e', 'h', 'i', 'f', 'g', 'j'}
>>> s1-s2   #取出s1中不包含s2的部分
{'c', 'b', 'a'}
>>> s2-s1   #取出s2中不包含s1的部分
{'l', 'k', 'h', 'i', 'j'}
>>> s1|s2   #取出s1与s2的并集
{'l', 'k', 'e', 'h', 'c', 'f', 'j', 'd', 'b', 'i', 'a', 'g'}
>>> s1&s2   #取出s1与s2的交集
{'d', 'f', 'g', 'e'}
>>> s1^s2   #取出s1与s2的并集但不包括交集的部分
{'l', 'k', 'h', 'i', 'b', 'c', 'a', 'j'}
>>> 'a' in s1 #判断'a'是否在s1中
True
>>> 'a' not in s1 #判断'a'是否在s1中
False

五、字典

1、字典简介
dict（字典）是另一种无序的对象集合。但与集合不同，字典是一种映射类型，每一个元素是一个键(key):值(value)对。字典中每一个元素以逗号隔开，key与value用冒号隔开。
在一个字典对象中，键必须是唯一的，即不同元素的键不能相同。另外，键必须是可哈希数据，即键不能是列表、元组、集合、字典等类型，值可以是任意类型。对于不包含任何元素的字典，即{}，称为空字典。
2、字典创建
创建字典既可以使用{}，也可以使用dict函数。
如下5种方式创建的5个字典对象的元素完全相同。

a = {'one':1,'two':2,'three':3} #创建字典a
b = dict(one = 1,two = 2,three = 3)#创建字典b
c = dict(zip(['one','two','three'],[1,2,3]))#创建字典c
d = dict([('one',1),('two',2),('three',3)])#创建字典d
e = dict({'one':1,'two':2,'three':3})#创建字典e

print(a)
print(b)
print(c)
print(d)
print(e)

输出结果：
{'one': 1, 'two': 2, 'three': 3}
{'one': 1, 'two': 2, 'three': 3}
{'one': 1, 'two': 2, 'three': 3}
{'one': 1, 'two': 2, 'three': 3}
{'one': 1, 'two': 2, 'three': 3}

zip函数的参数是多个可迭代的对象（列表等），其功能是将不同对象中对应的元素分别打包成元组，然后返回由这些元组组成的列表。
python3.x中为了减少内存，zip函数返回的是一个对象，可以通过list函数转换为列表。

print(list(zip(['one','two','three'],[1,2,3])))

输出结果：
[('one', 1), ('two', 2), ('three', 3)]

3、访问字典元素
与列表等序列对象不同，在访问字典中的元素时不能通过下标方式访问，而是通过键访问。

info = {'name':'张三','age':19,'score':{'python':95,'math':92}} #创建字典info
方式一：
print(info['name']) #输出张三
print(info['age']) #输出19
print(info['score'])#输出{'python': 95, 'math': 92}
print(info['score']['python']) #输出95
print(info['score']['math']) #输出92

方式二：
print(info.get('name')) #输出张三
print(info.get('age')) #输出19
print(info.get('score'))#输出{'python': 95, 'math': 92}
print(info.get('score').get('python'))#输出95
print(info.get('score').get('math'))#输出92

3、字典操作
字典常见操作：

info = {'name':'张三','age':19,'score':{'python':95,'math':92}} #创建字典info
info.items() #获取字典的项列表
info.keys() #获取字典的key列表
info.values() #获取字典的value列表
info.pop('name') #弹出key = 'name'的项
d = info.copy() #字典复制
info['class'] = 1005 #向字典中添加键值对'class': 1005
info.clear() #字典元素清除

六、序列

列表、元组和字符串统称为序列，它们具有如下共同点：
（1）都可以通过索引得到每一个元素；
（2）默认索引值总是从0开始；
（3）可以通过分片的方法得到一个范围内的元素的集合（例如list[beg,end]）；
（4）有很多共同的操作符（重复操作符、拼接操作符、成员关系操作符）
对序列的一些常用函数、操作符及其意义：

七、遍历函数map

Python的内置函数map()用于遍历序列，对序列中每个元素进行操作，最终获取新的序列。其语法为map(function,iterable)，其中function为函数，iterable为可迭代对象。在Python3中，map(function,iterable)返回的是一个对象，可用list(map(function,iterable))将其转换成列表。

一、结合lambda函数使用
a = [1,2,3,4,5]
list(map(lambda a:a+100,a))

输出结果：
[101, 102, 103, 104, 105]

二、结合自定义函数使用
def func(a):
    return a+100
    
if __name__ == '__main__':       
    a = [1,2,3,4,5]
    print(list(map(func,a)))

输出结果：
[101, 102, 103, 104, 105]

八、筛选函数filter

python中的内置函数filter()用于对序列中的元素进行筛选，最终获取符合条件的序列。其语法为filter(function,iterable)，其中function为函数，iterable为可迭代对象。在Python3中，与map函数一样，filter(function,iterable)返回的是一个对象，可用list(filter(function,iterable))将其转换成列表。

一、结合lambda函数使用
a = [1,2,3,4,5]
list(filter(lambda a:a>2,a))

输出结果：
[3, 4, 5]

二、结合自定义函数使用
def func(a):
    return a>2
    
if __name__ == '__main__':   
    a = [1,2,3,4,5]
    print(list(filter(func,a)))

输出结果：
[3, 4, 5]

九、累计函数reduce

reduce函数用于对序列内所有元素进行累计操作。从Python3开始，使用reduce函数时需要从functools模块导入。其语法为reduce(function,iterable,start)，function为有两个参数的函数，iterable为可迭代对象，start为初始值。

from functools import reduce

一、结合lambda函数使用
a = [1,2,3,4,5]
reduce(lambda arg1,arg2:arg1+arg2,a)

输出结果：
15

二、结合自定义函数使用
def func(a,b):
    return a+b
    
if __name__ == '__main__':
    a = [1,2,3,4,5]
    print(reduce(func,a))
输出结果：
15

python初阶—基础语法篇(一)