Python3基本数据类型

Python3基本数据类型

Python中的变量在使用前都无需声明，但是每个变量在使用前都需要赋值，变量赋值以后该变量才会被创建。
在Python中变量就是变量，它没有类型，我们所说的“类型”是变量所指的内存中对象的类型。

Python3标准数据类型（6个）：

Number：数字
String:字符串
List:列表
Tuple:元祖
Sets:集合
Dictionary:字典

Number（数字）:

Python3中数字有int（长整型）、float（浮点数）、bool（布尔）、complex（复数）
可以用内置的type()函数和isinstance来判断变量所指的对象类型，例如：
type():

a=10

b=2.5

c=True

d=1+3j

print(type(a),type(b),type(c),type(d))

输出：<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>

isinstance():

a=10

b=2.5

c=True

d=1+3j

print(isinstance(a,int),isinstance(b,float),isinstance(c,bool),isinstance(d,complex))

输出：True True True True

type与isinstance的区别在于：

class A:

   pass

class B(A):

   pass

print(isinstance(A(),A),

     type(A()) == A,

     isinstance(B(),A),

     type(B()) == A) 

输出：True True True False

文字说明：

type()不会认为子类是一种父类类型。

isinstance()会认为子类是一种父类类型。

注意：

1.Python中可以同时为多个变量赋值，例如:

a,b,c,d=10,2.5,True,1+3j

print(type(a),type(b),type(c),type(d))

输出：<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>

2.Python3中，True和False定义成关键字了，但它们的值还是1和0，它们可以和数字相加。

   例如：

print(True+True+False+False)#1+1+0+0

输出：2

3.一个变量可以通过赋值指向不同类型的对象

4.在混合计算时，Python会把整型转换为浮点数

5.复数由实数部分和虚数部分构成，可以用a+bj或者complex(a,b)表示，复数的实部a和虚部b都是浮点型

String（字符串）:

Python中的字符串有单引号('')或双引号('' '')，反斜杠(\)转义特殊字符。
用索引取字符：
语法：变量[开始下标:结束下标]
例如：
                    str = 'qwerdf'
                    print(str)          # 输出字符串
                    print(str[0:-1])    # 输出第一个到倒数第二个的所有字符
                    print(str[0])       # 输出字符串第一个字符
                    print(str[2:5])     # 输出从第三个开始到第五个的字符
                    print(str[2:])      # 输出从第三个开始的后的所有字符
                    print(str*2)        # 输出字符串两次
                    print(str+"df123")  # 连接字符串

输出：qwerdf

qwerd

q

erd

erdf

qwerdfqwerdf

qwerdfdf123

\n换行，如果你不想让\n换行，可以在字符串前面添加一个r，表示原始字符串：
   例如：

print('qwer\ndf')

输出： qwer

  df

print(r'qwer\ndf')

输出：qwer\ndf

反斜杠(\)可以作为续行符，表示下一行是上一行的延续。也可以使用 """...""" 或者 '''...''' 跨越多行
   例如：

print('qwer\

df')

输出：qwerdf

print('''qwer

df''')#"""..."""与'''..'''一样

输出：qwer

           df

注意：

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

2.Pyhon中的字符串有俩种索引方式，从左往右以0开始，从右往左以-1开始

   例如：

str = 'qwerdf'

print(str[0],str[5])

print(str[-1],str[-6])

输出：q f

 f q

3.Python中的字符串不能被改变，向一个索引位置赋值，比如str[0]='z'会报错。

List(列表):

列表是Python中使用最频繁的数据类型。

列表可以完成大多数集合类的数据结构实现，列表中元素的类型可以不相同，

它支持数字、字符串甚至可以包含列表（就是嵌套）。

列表是写在方括号([])之间，用逗号分隔开的元素列表。
列表和字符串一样，可以根据索引截取，列表被截取后返回一个包含所需元素的新列表。
用索引截取：
语法：变量[开始下标:结束下标]
实例：

list = [ 'qwer',123,1.23,'Python3',85.2 ]

tinylist = [456, 'Python2']

print (list)            # 输出完整列表

print (list[0])         # 输出列表第一个元素

print (list[1:3])       # 从第二个开始输出到第三个元素

print (list[2:])        # 输出从第三个元素之后所有元素（包括第三个元素）

print (tinylist * 2)    # 输出两次列表

print (list + tinylist) # 拼接列表

输出：

['qwer', 123, 1.23, 'Python3', 85.2]

qwer

[123, 1.23]

[1.23, 'Python3', 85.2]

[456, 'Python2', 456, 'Python2']

['qwer', 123, 1.23, 'Python3', 85.2, 456, 'Python2']

列表中的元素是可以改变的
例如：
                        a = [1, 2, 3, 4, 5, 6]
                        print(a)
                        a[0] = 9                # 修改一个元素
                        print(a)
                        a[2:6] = [13, 14, 15]   # 修改多个元素
                        print(a)
                        a[5:6] = [8]            # 添加一个元素
                        print(a)
                        a[6:9] = 24,15,45       # 添加多个元素
                        print(a)
                        a[2:3] = []             # 删除一个元素
                        print(a)
                        a[2:5] = []             # 删除多个元素
                        print(a)

输出：

 [1, 2, 3, 4, 5, 6]

                            [9, 2, 3, 4, 5, 6]

                            [9, 2, 13, 14, 15]

                            [9, 2, 13, 14, 15, 8]

                            [9, 2, 13, 14, 15, 8, 24, 15, 45]

                            [9, 2, 14, 15, 8, 24, 15, 45]

                            [9, 2, 24, 15, 45]

Tuple(元组):

元组与列表类似，不同之处在于元组的元素不可以改变。元组写在小括号(())里，元素之间用逗号隔开。
元组中的元素类型也可以不相同
例如：
                        tuple = [ 'qwer',123,1.23,'Python3',85.2 ]
                        tinytuple = [456, 'Python2']
                        print(tuple)             # 输出完整元组
                        print(tuple[0])          # 输出元组的第一个元素
                        print(tuple[1:3])        # 输出从第二个元素到第三个元素
                        print(tuple[2:])         # 输出从第三个元素之后所有元素（包括第三个元素）
                        print(tinytuple * 2)     # 输出两次元组
                        print(tuple + tinytuple) # 拼接元组
输出：

['qwer', 123, 1.23, 'Python3', 85.2]

qwer

[123, 1.23]

[1.23, 'Python3', 85.2]

[456, 'Python2', 456, 'Python2']

['qwer', 123, 1.23, 'Python3', 85.2, 456, 'Python2']

元组与字符串类似，可以被索引截取，从头截取（下标为0开始），从尾截取（下标为-1开始），

可以把字符串看作一种特殊的元组。

例如：

tup = (1, 2, 3, 4, 5, 6)

print(tup)

print(tup[0])

print(tup[1:5])

# tup[0] = 11报错，不能修改元组元素

输出：

(1, 2, 3, 4, 5, 6)

1

(2, 3, 4, 5)

虽然元组的元素不可被改变，但它可以包含可变的对象，比如list列表。
元组中包含0个元素或者1个元素比较特殊，有一些额外的语法规则：
tup = () #空元组
tup1 = (20,) #一个元素需要在元素后加逗号
注意：

string、list、tuple都属于sequence（序列）。

Set(集合）：

集合是一个无序不重复元素的序列，基本功能是进行成员关系测试和删除重复元素。
可以使用大括号{}或者set()函数创建集合，创建一个空集合必须用set()而不是{},因为{}是用来创建一个空字典。
实例：

   {}:

       number = {'one', 'two', 'three', 'four','four', 'five', 'six'}

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

                if('five' in number) :          # 成员测试

                    print('five 在集合中')

                else :

                    print('five 不在集合中')

                输出：

{'one', 'four', 'two', 'three', 'five', 'six'}

five 在集合中
             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', 'd', 'c', 'r', 'a'}

{'b', 'd', 'r'}

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

{'c', 'a'}

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

Dictionary(字典）：

字典是Python中另一个非常有用的内置数据类型。

列表是有序的对象结合，字典是无序的对象集合。俩者之间的区别在于：字典当中的元素通过键来存储的，

而不是通过偏移存储。

字典是一种映射类型，字典用{}标识，它是无序的键（key）：值（value）对集合。
其中的键（key）必须使用不可变类型。
在同一字典中，键必须是唯一的。
实例：
                dict = {}
                dict['a'] = "aaa"
                dict[1] = "111"
                tinydict = {'name': 'zs','age':18, 'sex': '男'}
                print(dict['a'])         # 输出键为 'one' 的值
                print(dict[1])           # 输出键为 2 的值
                print(tinydict)          # 输出完整的字典
                print(tinydict.keys())   # 输出所有键
                print(tinydict.values()) # 输出所有值
输出：

                    aaa

                    111

                    {'name': 'zs', 'age': 18, 'sex': '男'}

                    dict_keys(['name', 'age', 'sex'])

                    dict_values(['zs', 18, '男'])

构造函数dict()可以直接从键值对中构造字典，例如：
                print(dict([('one', 1), ('two', 2), ('three', 3)]))
                print({x: x**2 for x in (2, 4, 6)})
                print(dict(one=1, two=2, three=3))

输出：

  {'one': 1, 'two': 2, 'three': 3}

                    {2: 4, 4: 16, 6: 36}

                    {'one': 1, 'two': 2, 'three': 3}

注意：
字典中有一些内置函数，clear()、keys()、values()等。

Python数据类型转换：

int() 函数：用于将一个字符串会数字转换为整型。
语法: int(x, base=10)#x:数字或者字符串，base:可选，进制数，默认十进制,返回整型

long() 函数:将数字或字符串转换为一个长整型。
语法：long(x, base=10)#x:数字或者字符串，base:可选，进制数，默认十进制,返回长整型数

float() 函数用于将整数和字符串转换成浮点数。
语法：float([x])#x：数字或者字符串,返回浮点数

complex() 函数:用于创建一个值为 a+ bj 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，

则不需要指定第二个参数

语法：complex(a+bj)#a,b数字，返回一个复数
str() 函数:将对象转化为适于人阅读的形式。
语法：dict = {'runoob': 'runoob.com', 'google': 'google.com'}#返回一个对象的string格式
str(dict)

repr() 函数:将对象转化为供解释器读取的形式
语法：dict = {'runoob': 'runoob.com', 'google': 'google.com'}#返回一个对象的 string 格式
repr(dict)
eval() 函数：用来执行一个字符串表达式，并返回表达式的值
语法：x = 7
eval( '3 * x' )
tuple 函数：将列表转换为元组
语法：tuple( seq )#seq：要转换为元组的序列，返回元组

list() 方法：用于将元组转换为列表
语法：list( seq )#list：要转换为列表的元组，返回列表
set() 函数：创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等
语法：set([iterable])#iterable：可迭代对象对象，返回新的集合对象

dict() 函数：用于创建一个字典
语法：dict(a='a', b='b', t='t')    
dict(zip(['one', 'two', 'three'], [1, 2, 3]))

frozenset()： 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素

语法： a = frozenset('runoob')#返回新的 frozenset 对象，如果不提供任何参数，默认会生成空集合

chr()： 用一个范围在 range（256）内的（就是0～255）整数作参数，返回一个对应的字符

语法：print chr(48), chr(49), chr(97)  #返回值是当前整数对应的ascii字符

unichr() 函数：和 chr()函数功能基本一样， 只不过是返回 unicode 的字符
语法：unichr(97)#值为a

ord() 函数是 chr() 函数（对于8位的ASCII字符串）或 unichr() 函数（对于Unicode对象）的配对函数，它以一个字符

（长度为1的字符串）作为参数，返回对应的 ASCII 数值，或者 Unicode 数值，

如果所给的 Unicode 字符超出了你的Python 定义范围，则会引发一个 TypeError 的异常

语法：ord(c)#c：字符，返回值是对应的十进制整数

hex() 函数用于将10进制整数转换成16进制整数
语法：hex(x)#x：10进制整数，返回16进制整数

oct() 函数将一个整数转换成8进制字符串
语法：oct(x)#x：整数，返回8进制字符串