2018-03-01

day03-数据类型，类型转换，运算符

一、数据类型

列表类型(有序的数据的集合)

定义： 使用[] 定义一个列表 。列表里面的值可以是

1.定义一个空列表 []
2.下标可以读取列表值  classList[0]
3.也有同字符串的切片截取 eg:classList[:3] #截取下标3之前的数据
4.也有同字符串相同的'+' 和 '*''
5.列表也可以对称赋值[num1,num2] = [10, 20]
6.判断元素是否存在print('asd' in classList)

# --------------------------------------------------------------------------------
# 列表
classList = ['张三','李四','王五','a']
print(type(classList)) #
print(len(classList)) # 4
print(len('1234')) # 4 ？
print(type('1234')) # 

# 列表的切片
classList = [1,2,3,4,5,6,7,8,9,0]
print(classList[:3]) #[1, 2, 3]
print(classList) # [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
# 列表翻转函数
print(classList[::-1]) #[0, 9, 8, 7, 6, 5, 4, 3, 2, 1]
print(classList) #[1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
print(classList.reverse()) #None
print(classList) #[0, 9, 8, 7, 6, 5, 4, 3, 2, 1]
# 列表的元素相加
print(classList + classList)#[0, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 9, 8, 7, 6, 5, 4, 3, 2, 1]
# 列表元素的重复
print(classList*1)#[0, 9, 8, 7, 6, 5, 4, 3, 2, 1]

# --------------------------------------------------------------------------------
classList = ['A','B','C','D','E','F']
# 修改列表某元素
classList[0] = '*'
print(classList)#['*', 'B', 'C', 'D', 'E', 'F']
# classList[100] = '&'  #越界，报错
print(classList)#['*', 'B', 'C', 'D', 'E', 'F']

# 删除指定的元素
del classList[0]
print(classList)#['B', 'C', 'D', 'E', 'F']

# 删除列表
del classList
# print(classList[0])  #  NameError: name 'classList' is not defined

classList = ['A','B','C','D','E','F']
# 删除前两个元素
# print('mask')
print(classList)
classList[:2] = []
print(classList) #['C', 'D', 'E', 'F']
print('\n'*2)

# 互换两个元素
num1 = 10;   num2 = 20
print(num1,num2) #10 20
[num1,num2] = [num2,num1]
print(num1,num2) #20 10
print('\n'*2)

# 查找一个元素是否在列表里
classList = ['A','B','C','D','E','F']
print('A' in  classList)# 返回bool值 #True
print('\n'*2)

# 查找列表里的最大值
classList = ['A','B','C','D','E','F']
print(max(classList)) #F
print(min(classList)) #A
print('\n'*2)

# 统计某元素出现的次数
myList = ['a','b', 'c','d','s','a','a']
print(myList.count('a')) #3
print('\n'*2)

# 列表中追加值
myList.extend('值')
myList.extend(['金','银'])
print(myList)#['a', 'b', 'c', 'd', 's', 'a', 'a', '值', '金', '银']
print('\n'*2)

# 插入值 并且指定位置（下标）要填充的值
myList = ['0','1','2','3']
print(myList)#['0', '1', '2', '3']
myList.insert(0,'A')
print(myList)#['A', '0', '1', '2', '3']
myList.insert(0,['m','n'])
print(myList)#[['m', 'n'], 'A', '0', '1', '2', '3']
print('\n'*2)

# 将最后一个值弹出
myList = ['1','2','3','4']
myList.pop()
print(myList)#['1', '2', '3']
# 将指定位置的值弹出
myList.pop(0)
print(myList)#['2', '3']
print('\n'*2)

# 移除第一个匹配上的元素
myList = ['1','2','3','4','2','2','2']
myList.remove('2')
print(myList)#['1', '3', '4', '2', '2', '2']

# 清空列表
myList = ['1','2','3','4','2','2','2']
myList.clear()
print(myList)#[]
print('\n'*2)

# 列表追加值
myList = ['a']
myList.append('b')
print(myList)#['a', 'b']
print(myList.index('a'))#0
# print(myList.index('z')) # 不存在就报错了
print('\n'*2)

# 升序排列列表
myList = [9,2,73,4,72,8]
myList.sort()
print(myList)#[2, 4, 8, 9, 72, 73]
print('\n'*2)

# 翻转列表
myList = [54,57,8,9,5,23,4,5,76,1]
myList.reverse()
print(myList)#[1, 76, 5, 4, 23, 5, 9, 8, 57, 54]
print('\n'*2)

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2018/3/1 13:34
# @Author  : PXQL
# @Site    : 
# @File    : 
# @Software: PyCharm Community Edition
# =====================================================
# 深、浅 拷贝  <>


import copy


# # 深拷贝 浅拷贝
# num1 = 5
# num2 = num1
# num2 = 10
# print(id(num1))
# print(id(num2))
# print('\n'*2)


# 在 python 里不是以变量来存储地址 而是以内容 相同内容指向一个地址
# 浅拷贝指向一个地址
myList = [1,2,3,4,5,6,7,8,9]
myList2 = myList
print(id(myList))#1993309771656
print(id(myList2))#1993309771656
myList2[0] = 'a'
print(id(myList))#1993309771656
print(id(myList2))#1993309771656
print('\n'*2)


# 深拷贝 真正意义的拷贝
myList3 = ['a','b','c','d','e']
myList4 = myList3.copy()
myList4[0] = '1'
print(id(myList3))#1993309771848
print(id(myList4))#1993309773128
print(myList3)#['a', 'b', 'c', 'd', 'e']
print(myList4)#['1', 'b', 'c', 'd', 'e']
print('\n')


## copy 模块里的 copy.copy 仅仅是拷贝了一层，也叫做浅拷贝
myList5 = ['a','b','c','d','e',['0','1','2']]
myList6 = myList5.copy()
myList6[5][0] = 'G'
print(id(myList5));
print(myList5)
print(id(myList6));
print(myList6)
print('\n')
# --- 打印结果 ---
# 2612034362568
# ['a', 'b', 'c', 'd', 'e', ['G', '1', '2']]
# 2612034362504
# ['a', 'b', 'c', 'd', 'e', ['G', '1', '2']]


myList = ['1','a','f']
myList2 = copy.copy(myList)
myList[0] = 'd'
print(myList)
print(myList2)
print('\n')
# --- 打印结果 ---
# ['d', 'a', 'f']
# ['1', 'a', 'f']
# --- 打印结果 ---

myList = ['1','a','f',['df','fg']]
myList2 = copy.copy(myList)
myList[3][0] = 'd'
print(myList)
print(myList2)
print('\n')
# --- 打印结果 ---
# ['1', 'a', 'f', ['d', 'fg']]
# ['1', 'a', 'f', ['d', 'fg']]
# --- 打印结果 ---


# 深拷贝  真正字面意义上的拷贝
myList = ['1','a','f',['df','fg']]
myList2 = copy.deepcopy(myList)
myList[3][0] = 'www'
print(myList)
print(myList2)
print('\n')
# --- 打印结果 ---
# ['1', 'a', 'f', ['www', 'fg']]
# ['1', 'a', 'f', ['df', 'fg']]
# --- 打印结果 ---


values = [1,2,3]
values[1] = values
# 打印 [1, [...], 3]  打印的结果，说明了 （values[1] = values）没有赋值，只是设置了引用
print(values)


values = []
values = [1,2,3]
values[1] = values[:]
# 打印 [1, [1, 2, 3], 3]
print(values)

#  python 里的对象复制  只有三种 切片、深拷贝、浅拷贝

元组

# Python的元组与列表类似，不同之处在于元组的元素不能修改。
# 元组使用小括号，列表使用方括号。
# 元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。

tuple1 = (1,2,3)
print(type(tuple1))
tuple2 = ('dsds',"iueriwur564",5466,1.6889,7+8)
tuple3 = '1','2','3','4',"5",45,23,1010
print(type(tuple3))
# --- 打印结果 ---
# 
# 
# --- 打印结果 ---

# 创建空的元组
tup = ()
print(type(tup))
# --- 打印结果 ---
# 
# --- 打印结果 ---

# 元组中只包含一个元素时，需要在元素后面添加逗号
tup1 = (2)
print(type(tup1))
tup1 = (2,)
print(type(tup1))
# --- 打印结果 ---
# 
# 
# --- 打印结果 ---

# 元组的值是不能进行修改的
tup1 = (1,2,3)
# tup1[0] = 45  # 将要报错，原因是不能修改元组的值
print(tup1)
# 元组的值不能修改，但是元组内部包含其他层的嵌套的时候，我们可以修改嵌套的值，原因是其它层在这里只是存储的地址
tup2 = (1,4,5,['a','b'])
print(tup2)
tup2[-1][0] = 'http://www.baidu.com'
print(tup2)
# --- 打印结果 ---
# (1, 4, 5, ['a', 'b'])
# (1, 4, 5, ['http://www.baidu.com', 'b'])
# --- 打印结果 ---

#可以根据下标取值  也可以下标切片截取 与字符串和列表一样
#也有+ 和 *
tup1 = (1,2)
tup2 = (3,4)
print(tup1+tup2)
print(tup1*2)
# --- 打印结果 ---
# (1, 2, 3, 4)
# (1, 2, 1, 2)
# --- 打印结果 ---

# del tuple1 #不可以删除指定下标值  可以直接干掉所有的
tup1 = (1,2)
# del tup1[0]  # 报错
del tup1
# print(tup1) # 报错


#判断元素是否存在于元组中
# print(3 in tuple1)

tup1 = (1,2,3)
print(3 in tup1)
print(100 in  tup1)
# --- 打印结果 ---
# True
# False
# --- 打印结果 ---

集合

# 描述
# set() 函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。
# 语法
# set 语法：
# class set([iterable])
# 参数说明：
# iterable -- 可迭代对象对象；

# set() 函数创建一个无序不重复元素集就叫做 集合


set1 = {4}
print(type(set1)) #

#  是定义一个空字典
set1 = {}
print(type(set1)) #

#  是定义一个空集合
set1 = set()
print(type(set1)) #

# 不重复的序列
set1 = {1,1,2}
print(set1)

# 将列表里的去重
myList = [1,1,3,4,5,6,6,6,6,7,7]
set2 = set(myList)
print(set2)

# 集合的运算
set1 = {'a','b','c'}
set2 = {'a','d','e','f','g','h'}
# 取差值
set3 = set1 - set2
print(set3) #{'b', 'c'}
# 取并集
print(set1|set2) #{'f', 'd', 'b', 'e', 'h', 'g', 'c', 'a'}
# 取交集
print(set1&set2) #{'a'}
# 不同时存在的
print(set1^set2) #{'e', 'b', 'h', 'd', 'c', 'f', 'g'}

# 不能使用下标 没有 + *
set4 = {1,2,3,4,5}
print(set4)#{1, 2, 3, 4, 5}

字典

#字典类型 是有 key->value的形式组成  并且查找速度极快
#定义  {}
#key是由字符串和整数 组成
# 键值成对出现 key是唯一的

dict = {'name':'张三','age':18}
dict2 = {'address':"河南省郑州",'phone':'17718889999'}
# dict3 = dict + dict2  # 报错，字典不能相加 ，但是可以 更新 uppdate
dict3 = dict.update(dict2)
print(dict3)  # None  dict.update(dict2) 执行后返回了 None
print(dict)  #  {'name': '张三', 'age': 18, 'address': '河南省郑州', 'phone': '17718889999'}

dict =  {'name': '张三', 'age': 18, 'address': '河南省郑州', 'phone': '17718889999'}
# 长度 是 键值对的个数
print(len(dict))  # 4
# 查找值
print(dict["address"])  # 河南省郑州
dict4 = {110:'No'}
# 把 dict4 合并到 dict 里; dict4 重复的 key 的 value 会将 dict 里的 key 的 value 覆盖掉
dict.update(dict4)
print(dict) #{'name': '张三', 'age': 18, 'address': '河南省郑州', 'phone': '17718889999', 110: 'No'}
dict4 = {110:"YES"}
dict.update(dict4)
print(dict) #{'name': '张三', 'age': 18, 'address': '河南省郑州', 'phone': '17718889999', 110: 'YES'}
#  如果为没有的 key 赋值 value 则会先将 key 插入，然后再赋值 value
dict['safe'] = 'YES'
print(dict) #{'name': '张三', 'age': 18, 'address': '河南省郑州', 'phone': '17718889999', 110: 'YES', 'safe': 'YES'}

---

二、类型转换

str1 = str(10.45)
str2 = float('100')
print(str1)#10.45
print(str2)#100.0


set2 = set('12.5465665')
print(set2)#{'5', '2', '1', '4', '.', '6'}
print('\n'*2)


t1 = ('张华','李白','小乔','大乔')
classList = list(t1)
tup = tuple(t1)
print(t1);#('张华', '李白', '小乔', '大乔')
print(type(t1))#
print(classList);#['张华', '李白', '小乔', '大乔']
print(type(classList))#
print(tup);#('张华', '李白', '小乔', '大乔')
print(type(tup))#

# 将列表转为 字典 <注意格式>
list1 = [('name','张三'),('age',18)]
dic = dict(list1)
print(dic)#{'name': '张三', 'age': 18}
print(type(dic))#
list2 = ['a','b','c','d']
# dic = dict(list2) #报错 格式错误 不可以转


# 将集合转为 字典 <注意 格式>
set1 = {('name','张三'),('age',18),('address','郑州')}
dic1 = dict(set1)
print(dic1)#{'age': 18, 'name': '张三', 'address': '郑州'}
print(type(dic1))#
set2 = {'a','b','c','d'}
# dic3 = dict(set2) #报错 格式错误不可以转

三、运算符

1） 赋值运算符

=

2）算数运算符

+ - * / %  
**  求次方
// 求商 （10//3  ===> 3）

3）复合运算符

+=  # num += 1  === num=num+1
-=
*=
/=
%=
**=
//=

4） 比较运算符

> < >= <= != ==
3>4
比较运算符组成的表达式 返回值真和假

5）逻辑运算符

and  与  （短路原则 第一个为假直接结束）
逻辑与：
    表达式1    表达式2   结果
    真           真       真
    假           真       假
    假           假       假
or  或
逻辑或
    表达式1    表达式2   结果
    真           真       真
    假           真       真
    真           假       真
    假           假       假
    
not 非
逻辑非
    只要有一个表达式为真 即为假
    表达式   整个表达式
    真           假
    假           真

6）成员运算符

in  
not in
一般用于列表 元组 集合 字典的元素判断中
如果是字典按照键值查找 不是按照值

优先级：不记得优先级就加上小括号