02 . Python之数据类型

# Python 中的变量赋值不需要类型声明。
# 每个变量在内存中创建，都包括变量的标识，名称和数据这些信息。
# 每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。
# 等号（=）用来给变量赋值。
# 等号（=）运算符左边是一个变量名,等号（=）运算符右边是存储在变量中的值。例如：

conuter = 100
miles = 1000.0
name = "Json"

print (conuter)
print (miles)
print (name)

a = b = c = 1
print (a,b,c)

# 你也可以为多个对象指定多个变量,例如:
a, b , c = 1 , 2, "json"
print(a,b,c)

* Numbers（数字）
* String（字符串）
* List（列表）
* Tuple（元组）
* Dictionary（字典）

var1 = 10  
var2 = 20  

del var1[,var2[,var3[....,varN]]]  
  
# 也可以通过del语句删除单个或多个对象的引用，例如:  
del  var  
del  var_a,var_b  

>>> number = 0xA0F # 十六进制  
>>> number  
2575  
  
>>> number=0o37 # 八进制  
>>> number  
31  

* int(x) 将x转换为一个整数。  
    
* float(x) 将x转换到一个浮点数。  
    
* complex(x) 将x转换到一个复数，实数部分为 x，虚数部分为 0。  
    
* complex(x, y) 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式。  
  
# 以下实例将浮点数变量a转换为整数:  
a = 1.0  
print (int(a))  
1  

>>> 2 + 2  
4  
>>> 50 - 5*6  
20  
>>> (50 - 5*6) / 4  
5.0  
>>> 8 / 5  # 总是返回一个浮点数  
1.6  

>>> 17 / 3  # 整数除法返回浮点型  
5.666666666666667  
>>>  
>>> 17 // 3  # 整数除法返回向下取整后的结果  
5  
>>> 17 % 3  # ％操作符返回除法的余数  
2  
>>> 5 * 3 + 2   
17  
  
# 注意: //得到的不一定是整数类型的数，他与分母分子的数据类型有关系.  
>>> 7//2  
3  
>>> 7.0//2  
3.0  
>>> 7//2.0  
3.0  
>>>   

>>> width = 20  
>>> height = 5*9  
>>> width * height  
900  

>>> 5 ** 2  # 5 的平方  
25  
>>> 2 ** 7  # 2的7次方  
128  

>>> n   # 尝试访问一个未定义的变量  
Traceback (most recent call last):  
 File "<stdin>", line 1, in <module>  
NameError: name 'n' is not defined  

>>> 3 * 3.75 / 1.5  
7.5  
>>> 7.0 / 2  
3.5  

>>> tax = 12.5 / 100  
>>> price = 100.50  
>>> price * tax  
12.5625  
>>> price + _  
113.0625  
>>> round(_, 2)  
113.06  
# 此处，_ 变量应被用户视为只读变量  

var1 = 'Hello World!'  var2 = "Runoob"

s="a1a2···an"(n>=0)

# 他是编程语言中表示文本的数据类型
# Python的字符串有2中取值顺序:
# 从左到右索引默认是0开始的，最大范围是字符串长度为1.
# 从右到左索引默认-1开始的，最大范围是字符串开头

s = 'youmen'
print (s[1:5])

str = 'Hello Wrold'
print (str)
print (str[0])
print (str[2:5])
print (str[2:])
print (str * 2)
print (str + "TEST")

Hello Wrold
H
llo
llo Wrold
Hello WroldHello Wrold
Hello WroldTEST

var1 = 'hello world'
print(var1[:6] + 'Runnob!')

# 上面实例输出结果为
hello Runnob!

print('我叫%s 今年 %d 岁!' % ('小明',10))
我叫小明 今年 10 岁!

para_str = """这是一个多行字符串的实例
多行字符串可以使用制表符
TAB(t).
也可以是使用换行符[n].
"""
print(para_str)

# 以上实例输出结果为
这是一个多行字符串的实例
多行字符串可以使用制表符
TAB(    ).
也可以是使用换行符[
].
# 三引号让程序员从引号和特殊字符的泥潭里面解脱出来,自始至终保持一小块字符串的格式是所谓的所见即得格式.
# 一个典型用例是,当你需要一块HTML或者SQL时，这时用字符串组合，特殊字符串转义会非常的繁琐.

>>> name = 'Runoob'  
>>> 'Hello %s' % name  
'Hello Runoob'
# f-string格式和字符串以f开头，后面跟着字符串，字符串中的表达式用大括号{}包起来，
# 他会将变量或表达式计算后的值替换进去,实例如下.

name = 'Runoob'
print(f'Hello {name}')

age = 20
print(f'{age+1}')

w = {'name':'Runoob','url':'www.runoob.com'}
print(f'{w["name"]}:{w["url"]}')

Hello Runoob
21
Runoob:www.runoob.com

list1 = ['Google','Runoob',1997,2000]
list2 = [1,2,3,4,5]
list3 = ["a","b","c","d"]
# 注意: 后面的例子都是以这里的变量为模板

print("list1[0]", list1[0])
print("list2[1:3]",list2[1:3])

# 以上实例输出结果为:
list1[0] Google
list2[1:3] [2, 3]

print('list1第一个元素为:',list1[1])
list1[1] = 'youmen'
print('list1元素为:',list1[1])

# 以上实例输出结果为:
list1第一个元素为: Runoob
list1元素为: youmen

# 也可以使用append()方法

list3 = ["a","b","c","d"]
print("原始列表list3",list3)
del list3[0]
print("删除位置第0个元素",list3)

# 以上实例输出结果为
原始列表list3 ['a', 'b', 'c', 'd']
删除位置第0个元素 ['b', 'c', 'd']

# 当然，也可以使用remove()方法删除

L = ['Google','Runoob','Taobao']
print(L[2])
print(L[-2])
print(L[1:])

str1 = [ 1,4,9,13]
str1 += [15,18,20,22]
print(str1)

# 以上实例输出结果为
Taobao
Runoob
['Runoob', 'Taobao']
[1, 4, 9, 13, 15, 18, 20, 22]

stra = ['a','b','c']
strb = ['d','e','f']
strc = [stra,strb]
print(strc)
print(strc[0])
print(strc[0][1])

# 以上实例输出结果为:
[['a', 'b', 'c'], ['d', 'e', 'f']]
['a', 'b', 'c']
b

list = ['runoob',788,3.14,'youmen',77]
youmen = ['flying']

print(list)
print(list[0])
print(list[2:4])
print(list[2:])
print(list * 2)
print(list + youmen)

# 以上实例输出结果:
['runoob', 788, 3.14, 'youmen', 77]
runoob
[3.14, 'youmen']
[3.14, 'youmen', 77]
['runoob', 788, 3.14, 'youmen', 77, 'runoob', 788, 3.14, 'youmen', 77]
['runoob', 788, 3.14, 'youmen', 77, 'flying']

>>> stack = [3, 4, 5]   
>>> stack.append(6)   
>>> stack.append(7)   
>>> stack   
[3, 4, 5, 6, 7]   
>>> stack.pop()   
7   
>>> stack   
[3, 4, 5, 6]   
>>> stack.pop()   
6   
>>> stack.pop()   
5   
>>> stack   
[3, 4]  

>>> vec = [2, 4, 6]   
>>> [3*x for x in vec]   
[6, 12, 18]  
  
# 我们还可以对他进行幂计算:  
>>> [[x, x**2] for x in vec]   
[[2, 4], [4, 16], [6, 36]]  
  
# 可以对之前同样序列每一个元素逐个调用某方法:  
>>> freshfruit = ['  banana', '  loganberry ', 'passion fruit  ']   
>>> [weapon.strip() for weapon in freshfruit]   
['banana', 'loganberry', 'passion fruit']  
  
# 我们还可以使用if子句作为过滤器:  
>>> [3*x for x in vec if x > 3]   
[12, 18]   
>>> [3*x for x in vec if x < 2]   
[]  
  
# 以下是一些关于循环和其他技巧的演示:  
>>> vec1 = [2, 4, 6]   
>>> vec2 = [4, 3, -9]   
>>> [x*y for x in vec1 for y in vec2]   
[8, 6, -18, 16, 12, -36, 24, 18, -54]   
>>> [x+y for x in vec1 for y in vec2]   
[6, 5, -7, 8, 7, -5, 10, 9, -3]   
>>> [vec1[i]*vec2[i] for i in range(len(vec1))]   
[8, 12, -54]  
  
# 列表推导式可以使用复杂表达式或嵌套函数:  
>>> [str(round(355/113, i)) for i in range(1, 6)]   
['3.1', '3.14', '3.142', '3.1416', '3.14159']  

>>> matrix = [   
...     [1, 2, 3, 4],   
...     [5, 6, 7, 8],   
...     [9, 10, 11, 12],   
... ]  
  
# 以下实例将3X4的矩阵列表转换为4X3列表  
>>> [[row[i] for row in matrix] for i in range(4)]   
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]  
  
# 以下实例也可以使用以下方法实现:  
>>> transposed = []   
>>> for i in range(4):   
...     transposed.append([row[i] for row in matrix])   
...   
>>> transposed   
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]  

tup1 = (50)
print(type(tup1))
tup2 = (50,)
print(type(tup2))

<class 'int'>
<class 'tuple'>
# 元组与字符串类似，下标索引从0开始，可以进行截取，组合等.

tuple = ('runoob',788,3.14,'youmen',77)
youmen = (123, 'flying')

print(tuple)
print(tuple[0])
print(tuple[2:4])
print(tuple[2:])
print(tuple * 2)
print(tuple + youmen)

# 以上实例输出结果
('runoob', 788, 3.14, 'youmen', 77)
runoob
(3.14, 'youmen')
(3.14, 'youmen', 77)
('runoob', 788, 3.14, 'youmen', 77, 'runoob', 788, 3.14, 'youmen', 77)
('runoob', 788, 3.14, 'youmen', 77, 123, 'flying')

tup1 = (1,2,3)
tup2 = ('flying','youmen')
tup3 = tup1 + tup2
print(tup3)

(1, 2, 3, 'flying', 'youmen')

tup = ('Google','Runoob',1999,2000)
print(tup)
del tup
print("删除后的元组tup:")
print(tup)

('Google', 'Runoob', 1999, 2000)
删除后的元组tup:
Traceback (most recent call last):
  File "c:UsersYou-Men.vscodeextensionsms-python.python-2019.11.50794pythonFilesptvsd_launcher.py", 

# 以上实例元组被删除后，输出变量会有异常信息，输出如下所示:

删除后的元组 tup : 
Traceback (most recent call last):
  File "test.py", line 8, in <module>
    print (tup)
NameError: name 'tup' is not defined

tup = ('Google','Runoob',1999,2000)
print(tup[2])
print(tup[-2])
print(tup[1:])

# 以上实例输出结果
1999
1999
('Runoob', 1999, 2000)

>>> tup = ('r', 'u', 'n', 'o', 'o', 'b')  
>>> tup[0] = 'g'     # 不支持修改元素  
Traceback (most recent call last):  
  File "<stdin>", line 1, in <module>  
TypeError: 'tuple' object does not support item assignment  
>>> id(tup)     # 查看内存地址  
4440687904  
>>> tup = (1,2,3)  
>>> id(tup)  
4441088800    # 内存地址不一样了

# Example1
youmen = {'name':'tom','code':6379,'youmen':'flying'}
print(youmen['name'])
print(youmen['code'])

tom
6379

# Example2

dict = {'Alice': '1234','youmen':'22','Cecil':'3258'}
print("dict[Alice]",dict['Alice'])
print('dict[youmen]',dict['youmen'])

dict[Alice] 1234
dict[youmen] 22

dict = {'Alice': '1234','youmen':'22','Cecil':'3258'}
dict['Alice'] = 1
dict['youmen'] = 22
print(dict['Alice'])
print(dict['youmen'])

# 以下为实例输出结果
1
22

dict = {'Alice': '1234','youmen':'22','Cecil':'3258'}
del dict['Alice']
dict.clear()
del dict
print(dict['Alice'])

# 此时运行以上实例会报错，引发一个异常，因为用执行del操作后字典不再存在:

dict = {'Alice': '1234','youmen':'22','Cecil':'3258','Alice':'小菜鸟'}
print("dict['Alice']:",dict['Alice'])

# 以上实例输出结果为
小菜鸟

dict = {[Alice]: '1234','youmen':'22','Cecil':'3258','Alice':'小菜鸟'}

# 以上实例输出结果:

Traceback (most recent call last):
  File "test.py", line 3, in <module>
    dict = {['Name']: 'Runoob', 'Age': 7}
TypeError: unhashable type: 'list'

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


basket = {'apple','orange','apple','pear','orange','banana'}
print(basket)
print('apple' in basket)

# 以上实例输出结果为
{'apple', 'banana', 'orange', 'pear'}
True

# 下面展示两个集合间的运算
a = set('admin')
b = set('youmen')
print(a - b)		
print(a ^ b)
print(a | b)
print(a & b)

# 下面为实例的输出结果
{'i', 'd', 'a'}		# 集合a中包含b中不包含的元素
{'u', 'd', 'i', 'y', 'a', 'e', 'o'}
{'a', 'u', 'e', 'o', 'n', 'm', 'i', 'd', 'y'}  # 集合a和b都包含了的元素
{'n', 'm'}		# 集合a和b中都包含了的元素.

thisset = set(('admin','Google','Taobao'))
thisset.add('youmen')
print(thisset)
thisset.update('flying')
print(thisset)


# 以上实例输出结果
{'Taobao', 'Google', 'youmen', 'admin'}
{'admin', 'n', 'Taobao', 'y', 'f', 'Google', 'l', 'youmen', 'g', 'i'}

thisset = set(('admin','Google','Taobao'))
thisset.remove("Taobao")
print(thisset)

# 以上实例输出结果
{'admin', 'Google'}

# 计算集合元素个数
thisset = set(('admin','Google','Taobao'))
print(len(thisset))

3

# 清空集合
thisset.clear()
print(thisset)
set()

# 判断元素是否在集合中存在
x  in thisset
thisset = set(('admin','Google','Taobao'))
print('admin' in thisset)

True

>>> a = {x for x in 'YouMen' if x not in 'o'}   
>>> a   
{'e', 'u', 'Y', 'n', 'M'}   

>>> dict = {'nginx':80,'tomcat':8080,'Mysql':3306}   
>>> for i,k in dict.items():   
...         print(i,k)   
...   
nginx 80   
tomcat 8080   
Mysql 3306   
    
# 遍历序列可以使用enumerate()函数   
>>> for i ,v in enumerate(['tic','tac','toe']):   
...     print(i,v)   
...   
0 tic   
1 tac   
2 toe   
    
# 如果要反向遍历一个序列，首先指定这个序列，然后调用reversed()函数:   
>>> for i in reversed(range(1,10,2)):   
...         print(i)   
...   
9   
7   
5   
3   
1   
    
# 按顺序遍历一个序列，使用sorted()函数返回一个已排序的序列，并不修改原值:   
>>> dict = {'nginx':80,'tomcat':8080,'Mysql':3306,'Redis':6379,'NTP':123}   
>>> dict   
{'nginx': 80, 'tomcat': 8080, 'Mysql': 3306, 'Redis': 6379, 'NTP': 123}   
>>> for i in sorted(set(dict)):   
...     print(i)   
...   
Mysql   
NTP   
Redis   
nginx   
tomcat   

* 变量无须事先声明，也不需要指定类型
	* 动态语言的特性

* 编程中一般无须关心变量的存亡，也不用关心内存的管理
* Python使用引用计数记录所有变量的引用数.(引用计数器，垃圾回收机制)
	* 当变量引用数变为0，他就可以被垃圾回收GC
	* 计数增加: 赋值给其他变量就增加引用计数，例如x=3,y=x
	* 计数减少:
		* 函数运行结束时，局部变量会被自动销毁，对象引用计数减少
		* 变量被赋值给其他对象，例如x=3;y=x;x=4
	* 有关性能的问题，需要考虑变量的引用问题，但是该释放内存，还是尽量不释放内存，看需求.