Python3 笔记3 基本数据类型2

1.#如果列表的第三个参数为负数表示逆向读取，以下实例用于翻转字符串

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

2.Tuple 元组

与列表类似，不同之处在于元组的元素不能修改。元组写在小括号里()，用逗号隔开。

元组中的类型可以不同

tuple = ('abcd',786,2.23,'runoob',70.2)
tinytuple = (123,'runoob')print(tuple)
print(tuple[-1::-1])#tuple也支持翻转
print(tuple[2:])
print(tinytuple)
print(tinytuple[0])
print(tinytuple[-1::-1] * 2)
print('connect:',tuple+tinytuple)

#虽然tuple的元素不可改变，但它可以包含可变对象，比如list列表

tuple1 = ('abcd',123,[1,2,3,4])
print(tuple1)
print('tuple1.type():',type(tuple1))
print(tuple1)
#tuple1[2]=([1,2,4,4])TypeError: 'tuple' object does not support item assignmentlist1 = [1,2,3,4]
tuple2 =('abcd',123,list1)
print('tuple2old:',tuple2)
list1[2]=5
print('tuple2new:',tuple2)

#元祖与字符串类似，可以被索引且下标索引从0开始，-1为末尾开始的位置，也可以进行截取

tup=(1,2,3,4,5,6)
print(tup[0])
print(tup[5])
print('tup第二到第五:',tup[1:5])

#构造包含0个或者1个元素的元祖比较特殊，所以有一些额外的语法规则：

tup1=()
tup2=(20,)#单个元组的写法上必须带逗号以证明
tup3=(30)
print(tup1,'的类型是',type(tup1))
print(tup2,'的类型是',type(tup2))
print(tup2[0])
print('tup3',tup3,'的类型是',type(tup3))#不带逗号则不认为属于元祖

string list tuple都属于sequence(序列)

#1.与字符串一样，元祖的元素不能修改。

#2.元祖也可以被索引和切片，方法一样。

#3.注意构造包含0或1个元素的元祖的特殊语法规则。

#4.元祖可以使用+操作符进行拼接

3.SET集合

集合(set) 是由一个或者数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员。

基本功能是进行成员关系测试和删除重复元素。

可以使用大括号{}或者set()函数创建集合，注意：创建一个空集合必须用set()，{}用来创建一个空字典。

#创建格式

#parame={value1,value2,...}

#或者

#set(value)

sites = {'Google','Taobao','Runoob','Facebook','Zhihu','Baidu','Baidu'}
print('sites\'s type is ',type(sites))
sites1 = {}
print('sites1\'s type is ',type(sites1))
sites2 = ()
print('sites2\'s type is ',type(sites2))
#sites3 = set(12345)TypeError: 'int' object is not iterable
sites3 = set('12345')
print('sites3\'s type is ',type(sites3))

#输出集合重复的元素会被自动过滤掉

sites = {'Google','Taobao','Runoob','Facebook','Zhihu','Baidu','Baidu'}print('sites=',sites)#输出集合重复的元素会被自动过滤掉
#成员测试
if 'Runoob' in sites:print('Runoob在集合中')
else:print('Runoob不在集合中')#set可以进行集合运算,集合会过滤重复元素
a = set('abracadabra')
b = set('alaczam')
print(a)
print(b)
#计算差集
print(a - b)
print(b - a)
#计算并集
print(a | b)
#计算交集
print(a & b)
#计算非交集
print(a ^ b)

4.Dictionary 数据字典

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

列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于:字典中的元素是通过键来存取的，而不是通过偏移存取。

字典类型是一种映射类型，字典用{}标识，它是一个无序的键(key):值(value)的集合。

键(key)必须使用不可变类型。

在同一个字典中，键(key)必须是唯一的。

dict = {}#看起来像set()但设置集合为空只用set()这一种写法
dict['one'] = "1 - 菜鸟工程"
dict[2] = "2 - 菜鸟工程"tinydict = {'name':'runoob','code':1,'site':'www.runboob.com'}print(dict['one'])
print(dict)
print(tinydict)
print(tinydict['name'])
print(tinydict.keys())
print(dict.keys())
print(dict.values())

另外，字典类型也有一些内置函数，例如clear(),keys(),values()等

注意:

1.字典是一种映射类型，它的元素是键值对。

2.字典关键字必须为不可变类型，且不能重复。

3.创建空字典使用{}。

5.Python数据类型转换

1)语法 int(x[,base])

x -- 字符串或数字。

base -- 进制数，默认十进制。

int(x[,base]) 将 x转换为一个整数,base表示进制默认十进制，0也为十进制

x = 1
print('x=',x,'x为',type(x))
#int(x,0)
#print('x=',x,'x为',type(x))#TypeError: int() can't convert non-string with explicit base 非字符串类型似乎无法进行进制转换
x = '10'
y = int(x,0)#类型转换后得将值传到另一个参数才起作用
print('x=',x,'x为',type(x))
print('y=',y,'y为',type(y))
y = int(x,2)
print('x=',x,'x为',type(x))
print('y=',y,'y为',type(y))

2)语法 float([x])

x -- 整数或字符串

float(x)将x转换为浮点数

#float(x)将x转换为浮点数
x = 1
y = float(x)
print(y,'类型为',type(y))
x = '1'
y = float(x)
print(y,'类型为',type(y))
y = int(x)
print(y,'类型为',type(y))
x = 1.0
y = int(x)
print(y,'类型为',type(y))

3)语法 complex([real[, imag]])

complex(real[,imag]) 创建一个复数

#real -- int, long, float或字符串；

#imag -- int, long, float；

4)语法str(object='')

object -- 对象。

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

#str(x) 将对象x转换为字符串
s = 'number'
print('s的类型为',type(s))
p = str(s)
print('p的类型为',type(p))
t = 1,2,3,4#以下结果你会发现 会被默认为元组,意思默认会带着小括号
print('t的类型为',type(t))
p = str(t)
print('p的类型为',type(p))
t1 = [1,2,3,4]#直接会判定为 list由于[]中括号
print('t1的类型为',type(t1))
p = str(t1)
print('p的类型为',type(p))

5)语法repr(object)

object -- 对象。

repr(x) 将对象x转换为表达式字符串

主要针对于在解释器中，repr()会把传入的对象解释为字符串，原来已经是字符串的加上双引号""标识

而在正常的编译器结果则没有明显的区分，不知道具体用在何处，待今后实际场景进行补充；

#repr(x) 将对象x转换为表达式字符串
x = 'bsd'
print(type(x))
y = repr(x)
print(type(y))x = 10
print(type(x))
y = repr(x)
print(type(y))

6)语法：eval(expression[, globals[, locals]])

eval(str)用来计算在字符串中有效的python表达式，并返回一个对象
expression -- 表达式。
globals -- 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。

locals -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。

实际上通过实验暂时并未发现有什么相当特殊的地方，当前先记录为“可将含运算字符串，做一些运算的函数”

x = 132
y = eval('3 * x')
print(y)
str = '3 * x'
y1 = eval(str)
print('y1结果',y1)
z = eval('pow(2,3)')
print(z)
n = 10
t = eval('10-n')
print(t)

7)语法：tuple( iterable )

iterable -- 要转换为元组的可迭代序列

tuple(s) 将序列s转化为一个元组

tuple 函数将可迭代系列（如列表）转换为元组。

返回值会是一个元组

l = 1,2,3,4,5
print('l为',l,'数据类型为',type(l))
l1 = [1,2,3,4,5]
print('l1为',l1,'数据类型为',type(l1))
t = tuple(l1)
print('t为',t,'数据类型为',type(t))

8)语法:list( seq )

list(s) 将序列s转换为一个列表

list() 方法用于将元组或字符串转换为列表。

注：元组与列表是非常类似的，区别在于元组的元素值不能修改，元组是放在括号中，列表是放于方括号中。

l = 1,2,3,4,5
print('l为',l,'数据类型为',type(l))
t = list(l)
print('t为',t,'数据类型为',type(t))
str = 'wqnmlgb'
print('str为',str,'数据类型为',type(str))
t = list(str)
print('t为',t,'数据类型为',type(t))

9)语法:class set([iterable])

iterable -- 可迭代对象对象；

set(s) 转换为集合

set() 函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。

l = 1,2,3,4,5
print('l为',l,'数据类型为',type(l))
t = set(l)
print('t为',t,'数据类型为',type(t))
str = 'wqnmlgb'
print('str为',str,'数据类型为',type(str))
t = set(str)
print('t为',t,'数据类型为',type(t))

10)语法:class dict(**kwarg)

class dict(mapping, **kwarg)

class dict(iterable, **kwarg)

dict(d) 创建一个字典，d必须是一个(key,value) 元祖序列。

**kwargs -- 关键字

mapping -- 元素的容器。

iterable -- 可迭代对象

未完，待续--2020年10月10日17:31:35

11)语法：frozenset([iterable])

iterable -- 可迭代的对象，比如列表、字典、元组等等。

frozenset(s)转换为不可变集合

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

返回新的 frozenset 对象，如果不提供任何参数，默认会生成空集合。

a = frozenset(range(10))
print(a)
print('a的type为',type(a))
list1 = [1,2,3,4,5]
print(type(list1))
b = frozenset(list1)
print('b=',b,'b的类型为',type(b))

无论在编译器或者在调试器中，frozenset类型表现都是({xxx})，基于上下py3的演示结果，菜鸟的实例可能存在错误

12)语法：chr(i)

i -- 可以是10进制也可以是16进制的形式的数字。

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

chr(x) 将一个整数转换为一个字符

a = chr(10)
print('a=',a,'type(a)=',type(a))
print(a)
b = chr(48)
print(b)
print(type(b))print('chr(43)=',chr(43),'type(chr(43))=',type(chr(43)))
print('chr(44)=',chr(44),'type(chr(44))=',type(chr(44)))
print('chr(45)=',chr(45),'type(chr(45))=',type(chr(45)))
print('chr(46)=',chr(46),'type(chr(46))=',type(chr(46)))
print('chr(50)=',chr(50),'type(chr(50))=',type(chr(50)))

的确输出了一些结果，但目前并不明白chr(x)这种类型转换用在什么地方，后续补充

13)语法：ord(x)

x-- 字符。

ord(x) 将一个字符转换为它的整数值

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

返回值是对应的十进制整数。

a = ord('a')
b = ord('b')
c = ord('c')
print('ord(a)=',a,'type=',type(a))
print('ord(b)=',b,'type=',type(b))
print('ord(c)=',c,'type=',type(c))

执行结果如下，目前尚不清楚具体可用的场景，后续补充

14)语法hex(x)

x -- 10进制整数

hex() 函数用于将10进制整数转换成16进制，以字符串形式表示。

将一个整数转换为一个十六进制字符串

a = hex(1)
b = hex(22)
c = hex(333)
d = hex(4444)
print('a=',a,'type=',type(a))
print('b=',b,'type=',type(b))
print('c=',c,'type=',type(c))
print('d=',d,'type=',type(d))

执行结果如下，目前尚不清楚具体可用的场景，后续补充

15)语法：oct(x)

x -- 整数。

Python2.x 版本的 8 进制以 0 作为前缀表示。

Python3.x 版本的 8 进制以 0o 作为前缀表示

将一个整数转换为一个八进制字符串返回 8 进制字符串。

a = oct(1)
b = oct(22)
c = oct(333)
d = oct(4444)
print('a=',a,'type=',type(a))
print('b=',b,'type=',type(b))
print('c=',c,'type=',type(c))
print('d=',d,'type=',type(d))