05 元组 (8.13day04 一节)

"""

变量:
    id: 在内存中存储的位置;id(a)
    value: ==
    type:变量的数据类型; type(a)
==: value, type
is: 三个都判断

** a is b ====> True, a==b一定相等，返回True;
** a==b ====> True, a is b 不一定;

PyDev console: starting.
import sys; print('Python %s on %s' % (sys.version, sys.platform))
sys.path.extend(['/root/PycharmProjects/day04'])
Python 3.6.4 (default, Aug 7 2018, 11:03:35)
[GCC 4.8.2 20140120 (Red Hat 4.8.2-16)] on linux
a = '1'
b = 1
a == b
False
a = '1'
b = a
a is b
True
li = [1,2,3]
li1 = li
li == li1
True
li is li1
True
li2 = li.copy()
id(li)
140198653811208
id(li2)
140198653810120
li
[1, 2, 3]
li2
[1, 2, 3]
li == li2
True
li is li2
False

"""

"""
***面试常问:请简述赋值，深拷贝和浅拷贝的区别?(python中如何拷贝一个对象?)

- 直接赋值(li1 = li): 只传递对象的引用， li1指向对象li的内存地址空间,
因此，原有列表li改变，被赋值的li1也会做相应的改变.

- 浅拷贝(三种实现方式 eg： li2=li.copy()):li和li2的内存地址不同,
但是子对象的内存地址相同, 因此,原始数据改变，子对象也改变.

- 深拷贝(import copy, eg: li3=copy.deepcopy(li)), li和li3的内存地址不同，
包含子对象的拷贝，所以原始对象改变并不会造成深拷贝里面任何子项的改变.

*** 当深拷贝和浅拷贝，针对的对象全部是不可变数据类型时，两者效果相同;
*** 当深拷贝和浅拷贝，针对的对象包含是可变数据类型时，两者才有上述区别;

li = [1,2,3]
li1 = li
li.append(4)
li
[1, 2, 3, 4]
li1
[1, 2, 3, 4]
li2 = li[:]
li3 = li.copy()
li
[1, 2, 3, 4]
li.append(5)
li
[1, 2, 3, 4, 5]
li1
[1, 2, 3, 4, 5]
li2
[1, 2, 3, 4]
li3
[1, 2, 3, 4]
"""

# 列表里面嵌套列表

"""
li = [['a', 'b'], 2, 3, 4]
li2 = li[:]
li3 = li.copy()
id(li), id(li1), id(li2)
(140198666531528, 140198653810888, 140198653810824)
id(li), id(li1), id(li2), id(li3)
(140198666531528, 140198653810888, 140198653810824, 140198653949512)
li.append(5)
li, li2, li3
([['a', 'b'], 2, 3, 4, 5], [['a', 'b'], 2, 3, 4], [['a', 'b'], 2, 3, 4])
li[0].append('c')
li, li2, li3
([['a', 'b', 'c'], 2, 3, 4, 5], [['a', 'b', 'c'], 2, 3, 4], [['a', 'b', 'c'], 2, 3, 4])

li = [['a', 'b'], 1,2]
li2 = li.copy()
li
[['a', 'b'], 1, 2]
li2
[['a', 'b'], 1, 2]
id(li[0])
140198666473736
id(li2[0])
140198666473736

import copy
li
[['a', 'b'], 1, 2]
li2
[['a', 'b'], 1, 2]
li3 = copy.copy(li)
li4 = copy.deepcopy(li)
li
[['a', 'b'], 1, 2]
li4
[['a', 'b'], 1, 2]
id(li[0])
140198666473736
id(li4[0])
140198658766920

"""

# 所有的数值类型和布尔类型, str是不可变数据类型,
# list是可变数据类型;

# 浅拷贝的实现:
#   - li.copy()
#   - li[:]
#   - copy.copy(li)

# 实现深拷贝:
# - copy.deepcopy(li)

# 元组: 带了紧箍咒的列表;
# 不可变数据类型,没有增删改查;
# 可以存储任意数据类型;

li = [1, 2, 3]
li.append(4)
print(li)

# 定义元组
t = (1, 2.1, 2e+10, True, 2j+3, [1,2,3],(1,2,3) )
print(t, type(t))

# 如果元组里面包含可变数据类型，可以间接修改元组内容;
t1 = ([1,2,3], 4)
t1[0].append(4)
print(t1)
#
t2 = ()
t3 = tuple([])
# 元组如果只有一个元素，后面一定要加逗号, 否则数据类型不确定；
t4 = ('hello')
t5 = ('hello',)
print(type(t2), type(t3), type(t4), type(t5))

# 索引，切片，重复，连接，成员操作符

allowUsers = ('root', 'westos', 'fentiao')
allowPasswd = ('123', '456', '789')

print(allowUsers[0])
print(allowUsers[-1])
print(allowUsers[1:])
print(allowUsers[2:])
print(allowUsers[:-1])
print(allowUsers[::-1])

# 重复
print(allowUsers*3)

# 连接，
print(allowUsers + ('fensi', 'fendai'))

# 成员操作符
print('westos' in allowUsers)
print('westos' not in allowUsers)

# for循环
print("显示".center(50, '*'))
for user in allowUsers:
print("白名单用户:%s" %(user))

print("索引显示".center(50, '*'))
# # for循环并且求索引(枚举)
for index,user in enumerate(allowUsers):
print("第%d个白名单用户: %s" %(index+1, user))

# zip: 集和用户名和密码两个元组，元素之间一一对应
for user, passwd in zip(allowUsers, allowPasswd):
print(user,':', passwd)

t = (1,2, 'a', 'c', 'a')
print(t.index('c'))
print(t.count('a'))

#1. 变量交换数值:
a = 1
b = 2

b,a = a,b
# 1. 先把(a,b)封装成一个元组, (1,2)
# 2. b,a = a,b ======> b,a =(1,2)
# 3. b = (1,2)[0], a=(1,2)[1]
print(a,b)

# 打印变量值
name = 'westos'
age = 10
t = (name, age)
print("name: %s, age: %d" %(name, age))
print("name: %s, age: %d" %t)

# 元组的赋值: 有多少个元素，就用多少个变量接收
t = ('westos', 10, 100)
name, age,score = t
print(name, age, score)

#
scores = (100, 89, 45, 78, 65)
# 先对元组进行排序
# scoresLi = list(scores)
# scoresLi.sort()
# print(scoresLi)

scores = sorted(scores)
# python3中
minScore, *middleScore, maxScore = scores
print(minScore, middleScore, maxScore)
print("最终成绩为: %.2f" %(sum(middleScore)/len(middleScore)))