Python杂记（2）

python的基本数据类型

python中变量不需要声明，但是每个变量在使用前必须赋值，变量在赋值后才被创建，变量创建后类型就是其中内容的类型；
例：

counter = 100
miles = 100.2
name = "abcdef"

python中变量的赋值支持多个变量赋值
例：

a = b = c = 1

6种标准的数据类型
Number（数字）
String（字符串）
List（列表）
Tuple（元组）
Set（集合）
Dictionary（字典）

不可变数据：Number（数字）、String（字符串）、Tuple（元组）
可变数据：List（列表）、Set（集合）、Dictionary（字典）

查询变量所指的对象类型有两种方法
1.type()函数#type(变量名)，返回的是数据类型名称
2.isinstance()函数#isinstance(变量名,数据类型)，返回的时true或者false

这两者的区别在于type()不会认为子类是一种父类类型，而isinstance()会认为子类是一种父类类型

注意：在python2中是没有布尔型的，它用数字0表示false，数字1表示true。到python3中，把true和false定义成关键字了，但它们的值还是1和0，可以进行数字相加。

数值计算
可以不同的数据类型进行混合计算
在混合计算时，python会把整型转换成浮点数
在python中，数值的除法包含两个运算符：/返回一个浮点数，//返回一个整数
具体类型：
①加法 +
②减法 -
③乘法 *
④除法（返回浮点型）/
⑤除法（返回整数）//
⑥取余 %
⑦乘方 **

字符串（String）
在python中字符串既可以用’，也可以用"来表示，这两者是没有任何区别的。

字符串的截取格式：变量[头下标: 尾下标]
索引值以0为开始，-1为从末尾的开始位置

重要的一点，python中的字符串不能被改变，向一个索引位置赋值，比如word[0] = 'm'会导致错误

列表（List）
列表类似于结构体，在列表中的元素类型可以不同，它支持数字、字符串甚至可以包含列表（嵌套）
列表是卸载方括号[]之间、用逗号隔开的元素列表
列表和字符串一样可以被索引和截取，被截取后返回一个新列表
截取格式：变量[头下标: 尾下标]

在python中列表的元素可以被改变

python列表可以接收第三个参数，参数作用是截取的步长，以下是在索引1到索引4的位置并设置为步长为2（间隔一个位置）来截取字符串：

字符串逆序输出例子：

def reverseWords(input): 
      
    # 通过空格将字符串分隔符，把各个单词分隔为列表
    inputWords = input.split(" ") 
  
    # 翻转字符串
    # 假设列表 list = [1,2,3,4],  
    # list[0]=1, list[1]=2 ，而 -1 表示最后一个元素 list[-1]=4 ( 与 list[3]=4 一样) 
    # inputWords[-1::-1] 有三个参数
    # 第一个参数 -1 表示最后一个元素
    # 第二个参数为空，表示移动到列表末尾
    # 第三个参数为步长，-1 表示逆向
    inputWords=inputWords[-1::-1] 
  
    # 重新组合字符串
    output = ' '.join(inputWords) 
      
    return output 
  
if __name__ == "__main__": 
    input = 'I like runoob'
    rw = reverseWords(input) 
    print(rw)

最后输出结果为

runoob like I

元组（Tuple）
元组与列表相似，但是元组的元素不能修改，元组的元素写在小括号()里，分别用,隔开；
在元组中的元素类型也可以不同
字符串可以被看作是特殊的元组
虽然元组的元素不能修改，但是元组可以包含可变的对象，比如List列表；
构造包含0个或者1个元素的元组比较特殊，所以会有额外的语法规则：

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

集合（Set）
可以用大括号{}或者set{}函数创建集合，注意：创建一个空的集合必须用set{}而不是{}，因为{}是用来创建一个空的字典；
例：

parame = {value01,value02,...}

或者

set(value)

set也可以进行集合运算
例：

a = set('abracadabra')
b = set('alacazam')
 
print(a)
print(a - b)     # a 和 b 的差集
print(a | b)     # a 和 b 的并集
print(a & b)     # a 和 b 的交集
print(a ^ b)     # a 和 b 中不同时存在的元素

输出结果：

{'b', 'a', 'c', 'r', 'd'}
{'b', 'd', 'r'}
{'l', 'r', 'a', 'c', 'z', 'm', 'b', 'd'}
{'a', 'c'}
{'l', 'r', 'z', 'm', 'b', 'd'}

字典（Dictionary）
字典在python中是一个十分重要的内置数据类型；
列表与字典的区别：字典中的元素是通过键来存取的，而不是通过偏移存取
字典是一种映射类型，字典用{}标识，它是一个无序的键(key):值(value)的集合
键（key）必须使用不可变类型；并且在同一个字典中，键（key）必须是唯一的。
例：

dict = {}  #创建一个空的字典
dict['one'] = "1 - 菜鸟教程"  #赋予键为one的值为1 - 菜鸟教程
dict[2]     = "2 - 菜鸟工具"  #赋予键为2的值为2 - 菜鸟工具
 
tinydict = {'name': 'runoob','code':1, 'site': 'www.runoob.com'}

print (dict['one'])       # 输出键为 'one' 的值
print (dict[2])           # 输出键为 2 的值
print (tinydict)          # 输出完整的字典
print (tinydict.keys())   # 输出所有键
print (tinydict.values()) # 输出所有值

输出结果为：

1 - 菜鸟教程
2 - 菜鸟工具
{'name': 'runoob', 'code': 1, 'site': 'www.runoob.com'}
dict_keys(['name', 'code', 'site'])
dict_values(['runoob', 1, 'www.runoob.com'])

构造函数 dict() 可以直接从键值对序列中构建字典如下：

>>>dict([('Runoob', 1), ('Google', 2), ('Taobao', 3)])
{'Taobao': 3, 'Runoob': 1, 'Google': 2}#顺序不同是因为字典本身就是无序的对象集合
 
>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}#这个用类似for循环的东西一次为键2、4、6赋值
 
>>> dict(Runoob=1, Google=2, Taobao=3)
{'Runoob': 1, 'Google': 2, 'Taobao': 3}

python中的数据类型转换
常见的一些数据类型转换函数：

int(x,base)#将x转换为一个整数
①若x为纯数字，则不能有base参数，否则会报错；其作用为对入参x取整
例：

>>> int(3.1415926)
3
>>> int(-11.123)
-11
>>> int(2.5,10)
#报错
>>> int(2.5)
2

②若x为str，则base可有可无。
base存在时，视x为base类型数字，并将其转换为10进制数字。
若x不符合base规则，则报错
例：

>>>int("9",2)  #报错，因为2进制无9
>>> int("9")
9 
#默认10进制
>>> int("3.14",8)
>>> int("1.2")
#均报错，str须为整数
>>>int("1001",2)
9
# "1001"才是2进制格式，并转化为十进制数字9
>>> int("0xa",16)
10
# ≥16进制才会允许入参为a,b,c...
>>> int("b",8) #报错
>>> int("123",8)
83
#视123为8进制数字，对应的10进制为83

float(x)#将x转换为一个浮点数
例：

>>>float(1)
1.0
>>> float(112)
112.0
>>> float(-123.6)
-123.6
>>> float('123')     # 字符串
123.0

str(x)#将对象x转换为字符串
例：

>>>s = 'RUNOOB'
>>> str(s)
'RUNOOB'
>>> dict = {'runoob': 'runoob.com', 'google': 'google.com'};
>>> str(dict)
"{'google': 'google.com', 'runoob': 'runoob.com'}"

tuple(s)#将序列s转换为一个元组
例：

>>>list1= ['Google', 'Taobao', 'Runoob', 'Baidu']
>>> tuple1=tuple(list1)
>>> tuple1
('Google', 'Taobao', 'Runoob', 'Baidu')
>>> a= 'www'
>>> b=tuple(a)
>>> b
('w', 'w', 'w')
>>> a={'www':123,'aaa':234}
>>> b=tuple(a)
>>> b
('www', 'aaa')   # 将字段转换为元组时，只保留键！
>>> a=set('abcd')
>>> print (a)
{'c', 'd', 'b', 'a'}
>>> b=tuple(a)
>>> b
('c', 'd', 'b', 'a')

list(s)#将序列s转换为一个列表
aTuple = (123, 'Google', 'Runoob', 'Taobao')
list1 = list(aTuple)
print ("列表元素 : ", list1)

str="Hello World"
list2=list(str)
print ("列表元素 : ", list2)
输出结果为：
列表元素 :  [123, 'Google', 'Runoob', 'Taobao']
列表元素 :  ['H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd']

set(s)#转换为可变集合
例：

>>>x = set('runoob')
>>> y = set('google')
>>> x, y
(set(['b', 'r', 'u', 'o', 'n']), set(['e', 'o', 'g', 'l']))   # 重复的被删除
>>> x & y         # 交集
set(['o'])
>>> x | y         # 并集
set(['b', 'e', 'g', 'l', 'o', 'n', 'r', 'u'])
>>> x - y         # 差集
set(['r', 'b', 'u', 'n'])

dict(d)#创建一个字典。但d必须是一个(key,value)元组序列
例：
创建一个字典共有六种方法：
第一种：

>>> dict1 = {}
>>> dict1['firstname'] = 'ma'
>>> dict1['lastname'] = 'yun'

第二种：

>>> dict1 = {'firstname':'ma', 'lastname':'yun'}

第三种：

>>> dict1 = dict(firstname = 'ma', lastname = 'yun')

第四种：

>>> dict1 = dict([('firstname','ma'), ('lastname', 'yun')])

第五种：

>>> dict1 = dict((['firstname','ma'], ['lastname', 'yun']))

第六种：

>>> dict1 = dict(zip(['firstname', 'lastname'], ['ma', 'yun']))

列表、元组、集合是有所区别的

列表和元组不能合并，但是集合可以把相同的合并；
并且列表的表示是为[]，元组的表示是为()，集合的表示是为{}