【21天python打卡】第5天 基础语法（3）
大家好，今天是21天python打卡的第5天，上一篇python的顺序语句结构，条件和分支语句以及循环语句。今天我们继续讲解python基础语法，关于数据类型和字符串类型表示以及操作（索引和切片），最后我们简单举例部分函数的说明。
活动地址：CSDN21天学习挑战赛
学习的最大理由是想摆脱平庸，早一天就多一份人生的精彩；迟一天就多一天平庸的困扰。
目录
数据类型
数字类型
字符串类型
字符串表示
单引号、双引号
三重引号
转义字符
raw字符串
字符串操作
索引和分片
列表list
初始化列表
访问列表
列表操作
列表函数
元组tuple
元组初始化
元组函数
命名元组
字典dict
集合set
内置函数
数据类型
python的数据类型分为基本数据类型和复合数据类型
基本数据类型包含：数字,字符串复合数据类型包含：列表,元组,字典,集合
数字类型
和其他编程语言相比，Python语言中的变量不需要显示数据类型的声明，Python的变量类型是根据变量的赋值内容而自动生成的。
Python 六大数据类型：
- 数字: 包含int(整型)、
long(长整型，但python3中已经没有了，python3中只有int)、complex(复数)、float(浮点型)、bool(布尔型) - 字符串（String）: 比如：“hello world”，“python”
- 列表（List）: 比如：[1,2,3,4]，[’a‘,‘b’,‘c’,‘d’]
- 字典（Dictionary）:例如：{“name”:“poge”,“age”:30}
- 元组（Tuple）: 例如：(1,‘hello’,3)
- 集合（Set）:例如：{’a‘,’b‘,’c‘,’d‘}
以上是Python最基本的6种数据类型
数字类型：
表示数字或数值的数据类型称为数字类型。
数字类型有哪些？
- 整型（int）
- 浮点型（float）
- 复数类型（complex）
- 布尔类型（bool）
tips:Python中使用type()函数可以查看变量的类型
字符串类型
字符串表示
在python语言中，字符串的表示有以下三种：
- 单引号 ’
- 双引号 "
- 三重引号 “”"
单引号、双引号
在Python语言中，使用单引号(’ ')和双引号(" ")表示字符串是最常见的两种方式。
两种方式表示的字符串是等价的，且返回相同类型的对象。
单引号和双引号表示字符串没有本质的区别，可以在一种引号中嵌套另一种引号。
单引号和双引号表示的字符串是等价的，要配对出现，不能混用。否则将引发语法错误。
三重引号
三重引号可以是三个单引号，也可以是三个双引号。这种方式表示的字符串也叫做块字符串。
三重引号是以三个同一种类型的引号开始，并以三个相同引号结束的字符串表示方式。
转义字符
Python语言使用反斜杠()表示转义字符。
转义字符是为了对其后紧接的字符进行转义，屏蔽其特殊含义，并将其作为普通字符来输出。
raw字符串
raw字符串的格式是r’…’。
在raw字符串中，所有的字符都是直接按照字面意思来解释，没有转义字符或者不能打印的字符。
字符串操作
Python语言中包含字符串的以下几个基本操作：
- 字符串的索引
- 字符串的分片
- 字符串的合并
- 重复字符串
- 其他操作
索引和分片
-
索引
在Python语言中，字符串是一个有序字符的集合。
在一个字符串被创建之后，其中字符的相对位置就固定了。第一个字符的索引编号定义为0，第二个字符索引编号为1，以此类推。在Python语言中，对字符串可以进行正向索引和反向索引。
下表直观表示了字符串中字符和其索引编号的对应关系：
上表中，中间行表示的是字符串中的每个字符内容，上面行表示该字符串正向索引时的索引编号，下面行表示该字符串反向索引时的索引编号。索引是对单个元素进行的操作，Python语言中字符串的索引是通过元素下标进行索引的。
-
切片
使用Python语言的分片(slice)操作，来提取字符串中的子序列。
列表list
初始化列表
指定元素初始化列表
>>> num=['aa','bb','cc',1,2,3]
>>> print num
['aa', 'bb', 'cc', 1, 2, 3]从字符串初始化列表
>>> a='oiawoidhoawd97192048f'
>>> num=list(a)
>>> print num
['o', 'i', 'a', 'w', 'o', 'i', 'd', 'h', 'o', 'a', 'w', 'd', '9', '7', '1', '9', '2', '0', '4', '8', 'f']从元组初始化列表
>>> a=(1,2,3,4,5,6,7,8)
>>> num=list(a)
>>> print num创建一个空列表
>>> num=[]
>>> print num
[]用某个固定值初始化列表
>>> initial_value=0
>>> list_length=5
>>> sample_list=[initial_value]*list_length
>>> print sample_list
[0, 0, 0, 0, 0]
>>> sample_list=[initial_value for i in range(10)]
>>> print sample_list
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]访问列表
访问单个元素
>>> num=[0,1,2,3,4,5,6,7]
>>> num[3]
3
>>> num=[0,1,2,3,4,5,6,7]
>>> num[0]
0
>>> num[-1]
7
>>> num[-3]
5遍历整个列表
num=[0,1,2,3,4,5,6,7]
for a in num:
print a,
for i in range(len(num)):
print num[i],输出结果：0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7
列表操作
更新列表
>>> num=[0,1,2,3,4,5,6,7]
>>> num[1]='abc'
>>> print num
[0, 'abc', 2, 3, 4, 5, 6, 7]删除列表元素
num=[0,1,2,3,4,5,6,7]
for i in range(len(num)):
print num[i],
del num[2]
print num输出结果：0 1 2 3 4 5 6 7 [0, 1, 3, 4, 5, 6, 7]
列表操作符+*
列表对+和的操作符与字符串相似。+号用于组合列表，号用于重复列表。
以下为+操作符
>>> a=['a','b','c']
>>> b=['d','e','f']
>>> c=a+b
>>> print c
['a', 'b', 'c', 'd', 'e', 'f']以下为*操作符
>>> a=['a','b','c']
>>> c=a*4
>>> print c
['a', 'b', 'c', 'a', 'b', 'c', 'a', 'b', 'c', 'a', 'b', 'c']列表函数
以下是列表相关函数的分类
元组tuple
Python的元组与列表类似，不同之处在于元组的元素不能修改；元组使用小括号()，列表使用方括号[]；元组创建很简单，只需要在括号中添加元素，并使用逗号(,)隔开即可。
元组初始化
>>> t = (1, 2, 3)
>>> print(t)
(0, 1, 2)
>>> t = tuple(range(3))
>>> print(t)
(0, 1, 2)元组函数
关于tuple相关的函数可以使用help命令获得。
help(tuple)Help on class tuple in module builtins:
class tuple(object)
| tuple() -> empty tuple
| tuple(iterable) -> tuple initialized from iterable's items
|
| If the argument is a tuple, the return value is the same object.
|
| Methods defined here:
|
| count(...)
| T.count(value) -> integer -- return number of occurrences of value
|
| index(...)
| T.index(value, [start, [stop]]) -> integer -- return first index of value.
| Raises ValueError if the value is not present.list和index方法的使用和list一模一样。
命名元组
Python有一个类似tuple的容器namedtuples（命名元组），位于collection模块中。namedtuple是继承自tuple的子类，可创建一个和tuple类似的对象，而且对象拥有可访问的属性。
在c/c++中，对应的数据类型是结构体struct。
struct Point//声明一个结构体类型Point,代表一个点
{
int x; //包括一个整型变量x
int y; //包括一个整型变量y
}; //最后有一个分号这样就声明了一个新的结构体类型Point，有了类型就可以定义结构体的变量了。
Point p1,p2;在c/c++中结构体的最大作用在于组织数据，也就是对数据的封装（可以把结构体理解为特殊的类）。在python中起相同作用的就是命名元组了。命名元祖的具体使用如下
>>> from collections import namedtuple #依赖collections包的namedtuple模块
>>> Point = namedtuple('Point', 'x,y')
>>> p1 = Point(11, y=22)
>>> p1
Point(x=11, y=22)
>>> type(p1)
__main__.Point
>>> p1.x
11
>>> p1.y
22
>>> p1[0] + p1[1]
33
>>> a, b = p1
>>> a, b
(11, 22)命名元祖的具体使用可以参见：namedtuple()以及python 命名元组
字典dict
字典相关的所有内容如下
字典(dictionary)是除列表之外python中最灵活的内置数据结构类型。列表是有序的对象结合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'};每个键与值必须用冒号隔开(:)，每对用逗号分割，整体放在花括号中({})。键必须独一无二，但值则不必；值可以取任何数据类型，但必须是不可变的，如字符串，数或元组。
集合set
集合相关的所有内容如下
内置函数
一、数学相关
abs(a) : 求取绝对值。abs(-1)
max(list) : 求取list最大值。max([1,2,3])
min(list) : 求取list最小值。min([1,2,3])
sum(list) : 求取list元素的和。 sum([1,2,3]) >>> 6
sorted(list) : 排序，返回排序后的list。
len(list) : list长度,len([1,2,3])
divmod(a,b): 获取商和余数。 divmod(5,2) >>> (2,1)
pow(a,b) : 获取乘方数。pow(2,3) >>> 8
round(a,b) : 获取指定位数的小数。a代表浮点数，b代表要保留的位数。round(3.1415926,2) >>> 3.14
range(a[,b]) : 生成一个a到b的数组,左闭右开。 range(1,10) >>> [1,2,3,4,5,6,7,8,9]
二、类型转换
int(str) : 转换为int型。int('1') >>> 1
float(int/str) : 将int型或字符型转换为浮点型。float('1') >>> 1.0
str(int) : 转换为字符型。str(1) >>> '1'
bool(int) : 转换为布尔类型。 str(0) >>> False str(None) >>> False
bytes(str,code) : 接收一个字符串，与所要编码的格式，返回一个字节流类型。bytes('abc', 'utf-8') >>> b'abc' bytes(u'爬虫', 'utf-8') >>> b'\xe7\x88\xac\xe8\x99\xab'
list(iterable) : 转换为list。 list((1,2,3)) >>> [1,2,3]
iter(iterable)： 返回一个可迭代的对象。 iter([1,2,3]) >>>
dict(iterable) : 转换为dict。 dict([('a', 1), ('b', 2), ('c', 3)]) >>> {'a':1, 'b':2, 'c':3}
enumerate(iterable) : 返回一个枚举对象。
tuple(iterable) : 转换为tuple。 tuple([1,2,3]) >>>(1,2,3)
set(iterable) : 转换为set。 set([1,4,2,4,3,5]) >>> {1,2,3,4,5} set({1:'a',2:'b',3:'c'}) >>> {1,2,3}
hex(int) : 转换为16进制。hex(1024) >>> '0x400'
oct(int) : 转换为8进制。 oct(1024) >>> '0o2000'
bin(int) : 转换为2进制。 bin(1024) >>> '0b10000000000'
chr(int) : 转换数字为相应ASCI码字符。 chr(65) >>> 'A'
ord(str) : 转换ASCI字符为相应的数字。 ord('A') >>> 65
三、功能相关
eval() : 执行一个表达式，或字符串作为运算。 eval('1+1') >>> 2
exec() : 执行python语句。 exec('print("Python")') >>> Python
filter(func, iterable) : 通过判断函数fun，筛选符合条件的元素。 filter(lambda x: x>3, [1,2,3,4,5,6]) >>>
map(func, *iterable) : 将func用于每个iterable对象。 map(lambda a,b: a+b, [1,2,3,4], [5,6,7]) >>> [6,8,10]
zip(*iterable) : 将iterable分组合并。返回一个zip对象。 list(zip([1,2,3],[4,5,6])) >>> [(1, 4), (2, 5), (3, 6)]
type()：返回一个对象的类型。
id()： 返回一个对象的唯一标识值。
hash(object)：返回一个对象的hash值，具有相同值的object具有相同的hash值。 hash('python') >>> 7070808359261009780
help()：调用系统内置的帮助系统。
isinstance()：判断一个对象是否为该类的一个实例。
issubclass()：判断一个类是否为另一个类的子类。
globals() : 返回当前全局变量的字典。
next(iterator[, default]) : 接收一个迭代器，返回迭代器中的数值，如果设置了default，则当迭代器中的元素遍历后，输出default内容。
reversed(sequence) ： 生成一个反转序列的迭代器。 reversed('abc') >>> ['c','b','a']
今天就分享到这里，下一篇我们介绍面向对象。