多个变量赋值

a=b=c=1

也可以将三个变量赋予不同的值

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

标准数字类型

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

一、Number（数字）

python3支持int、float、bool、complex
int即为长整型
type()以及isinstance()函数可以查询变量所指的对象类型

a,b,c,d,e=12,0.5,"string",True,5+3j
print(type(a) ,type(b) ,type(c) ,type(d) ,type(e))
print(isinstance(a,int))

输出

<class 'int'> <class 'float'> <class 'str'> <class 'bool'> <class 'complex'>
True

两者区别
type()不会认为子类是一种父类类型
isinstance()会认为子类是一种父类类型

>>> class A:
...     pass
... 
>>> class B(A):
...     pass
... 
>>> isinstance(A(), A)
True
>>> type(A()) == A 
True
>>> isinstance(B(), A)
True
>>> type(B()) == A
False

在python3中bool类型的true flase可以与数字相加减
可以用del语句删除一些对象引用
关于del的赘述下篇进行。
数值运算

5+4     #加法
5-4     #减法
5*4     #乘法
5/4     #除法 **得到一个浮点数**
5//4    #除法 **得到一个整数**
5%4     #取余
5**4    #乘方

虚数赋值

a=1+4j
b=complex(1,3)
print(a ,b)

输出

(1+4j) (1+3j)

二、String（字符串）

单双引号都可以，以及字符截取，正0倒-1
+连接*复制\连接多行

三、链表

其可以完成大多数集合类的数据结构实现，列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表。
列表是写在方括号[]之间，用逗号分隔开的元素列表。
和字符串一样，列表同样可以被索引和切片，列表被截取后返回一个包含截取元素的新列表
截取方法与String类似,+*的运算也想通
定义方法：

a=[1,"234"]
b=[3,4.5,a,"123"]
print(b)

输出

[3, 4.5, [1, '234'], '123']

与String不一样的是List中的元素可以改变。

四、Tuple（元组）

与List类似，不同之处在于元素不可修改，写在小括号（）内。
同样可以被索引和切片
虽然Tuple的元素不可改变，但是它可以包含可变的对象，比如list
构造包含0或1个元素的Tuple比较特殊，实例：

tup1=()     #空元组
tup2=(20,)  #一个元素，需要在元素后添加逗号
a=[1,"123"]
c=(1,1.5,"adaw",a)
print(c)
a[0]=3
print(c)

输出

(1, 1.5, 'adaw', [1, '123'])
(1, 1.5, 'adaw', [3, '123'])

string,list,tuple都属于sequence（序列）

五、Set（集合）

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

parame = {value01,value02,...}
或者
set(value)

实例：

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

print(student)   # 输出集合，重复的元素被自动去掉

# 成员测试
if 'Rose' in student :
    print('Rose 在集合中')
else :
    print('Rose 不在集合中')


# 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 中不同时存在的元素

实例输出结果：

{'Mary', 'Jim', 'Rose', 'Jack', 'Tom'}
Rose 在集合中
{'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（字典）

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

实例：

dict = {}
dict['one'] = "1 - 菜鸟教程"
dict[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()可以直接从键值对序列中构建字典如下：

a1=dict([('Runoob', 1), ('Google', 2), ('Taobao', 3)])
a2={x: x ** 2 for x in (2, 4, 6)}
a3=dict(Runoob=1, Google=2, Taobao=3)

print(a1 ,a2 ,a3)

输出

{'Runoob': 1, 'Google': 2, 'Taobao': 3} {2: 4, 4: 16, 6: 36} {'Runoob': 1, 'Google': 2, 'Taobao': 3}

python数据类型转化

内容
int(x) 将x转化为整数
float(x) 将x转化为一个浮点数
complex(x,y) 将参数转化为复数
str(x) 将x转化为字符串
repr(x) 将x转化为表达式字符串
eval(str) 用来计算在字符串中的有效python表达式并返回一个对象
tuple(s) 将s转化为一个元组
list(s) 将序列s转化为一个列表
set(s) 转化为可变集合
dict(d) 创建一个字典，d必须是一个（key,value）元组数据
fozenset(s) 转化为不可变集合
chr(x) 将一个整数转化为一个字符
ord(x) 讲一个字符转化为它的整数值
hex(x) 将一个整数转化为16进制字符串
oct(x) 将一个整数转化为8进制字符串

int()

语法： class int(x,base=10)
参数 x--字符串或数字;base--进制数，默认十进制
返回值 整型数据，对数字取整
实例

int()           #不传入参数默认为0
int(3)
int(3.6)
int('12',16)    #如果base参数不为零，则X需要带''
int('0xa',16)
int('10',8)

注意base不为零时的特殊性

float()

参数 x-整数或字符串（字符串必须是数字）
返回值 浮点数

complex(x,y)

参数 x-int,long,float或字符串；y-int,long,float
实例：

print(complex(1,2))
print(complex(1))
print(complex("1"))
print(complex('1+2j'))      #"+"两侧不能有空格，否则会报错

输出

(1+2j)
(1+0j)
(1+0j)
(1+2j)

str()

语法 str(object='')
参数 object-对象
返回值 返回一个对象的string格式

实例：

dict = {'runoob': 'runoob.com', 'google': 'google.com'}
print(str(dict))

输出

{'runoob': 'runoob.com', 'google': 'google.com'}

repr()

描述 repr()将对象转化为供解释器读取的形式
参数返回值跟str()有一定区别

eval()

语法 eval(expression,globals,locals)
参数
expression--表达式,必须是string
globals--变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。
locals--变量作用域，局部明明空间，如果被提供，可以是任何影射对象。
返回值 返回表达式计算结果
实例

x=7
print(eval('3*x'))
print(pow(2,2) ,eval('pow(2,2)'))
print(eval('3+2'))
n=4
print(eval('n+4'))

输出

tuple()

语法 tuple(iterable)
参数 iterable--要转化的可迭代序列
返回值 返回元组
实例

list=['123','abc','...']
string1='12qw..'
set1=set('abcd')
dic={"1":'ads',"2":1,"3":[4.2,4]}
tuple1=tuple(list)
tuple2=tuple(string1)
tuple3=tuple(set1)
tuple4=tuple(dic)
print(tuple1)
print(tuple2)
print(tuple3)
print(tuple4)

输出

('123', 'abc', '...')
('1', '2', 'q', 'w', '.', '.')
('c', 'd', 'a', 'b')
('1', '2', '3')

注意当将字典转化为元组时，只会将键转化为元组序列，string会将各个元素分割

list()

语法 list(seq)
参数 seq--要转化为列表的元组或字符串
返回值 返回列表

set(iterable)

参数 iterable--可迭代对象
返回值 返回新的集合对象

dict()

语法
dict(kwarg)
dict(mapping,kwarg)
dict(iterable,kwarg)
**参数
kwarg--关键字
mapping--元素的容器
iterable--可迭代对象
返回值 一个字典
实例

print(dict())
print(dict(a='a',b='b',c='c'))
print(dict(zip(['one','two','three'],[1,2,3])))
print(dict([('one',1),('two',2),('three',3)]))

输出

{}
{'a': 'a', 'b': 'b', 'c': 'c'}
{'one': 1, 'two': 2, 'three': 3}
{'one': 1, 'two': 2, 'three': 3}

frozenset(iterable)

描述返回一个冻结的集合，冻结后的集合不能在添加删除任何元素
参数 iterable--可迭代对象：列表、字典、元组等。
返回值 返回新的frozenset对象，如果不提供任何参数，默认返回空集合

为什么要冻结集合？
因为集合A是另外一个集合B的元素情况，集合B在特定情况下其不可变化，但是集合A本身是可变的，那么它的实例就不能放在另一个集合B，所以需要冻结

chr()

描述用一个范围（0-255）整数作参数，返回一个对应的字符
语法 chr(i)
参数 i--可以使10进制的可以使16进制形式的数字
返回值 返回证书对应的ASCII组字符
实例

print(chr(0x21),chr(0x91),chr(0x73))
print(chr(33),chr(145),chr(115))

输出

!  s
!  s

ord()

描述
ord() 函数是 chr() 函数（对于8位的ASCII字符串）或 unichr() 函数（对于Unicode对象）的配对函数，它以一个字符（长度为1的字符串）作为参数，返回对应的 ASCII 数值，或者 Unicode 数值，如果所给的 Unicode 字符超出了你的 Python 定义范围，则会引发一个 TypeError 的异常。
语法 ord(c)
参数 c--字符
返回值 十进制数

hex()、oct(x)

描述分别将整数转化为16进制和8进制

Python基本数据类型的相关补充