python学习日记（基础数据类型及其方法02）

python的变量

python中的变量不需要声明，变量载使用前必须被赋值，变量被赋值以后才会被创建。

在python中变量就是变量，没有数据类型。我们所说的类型是变量所指向内存中的对象的类型。

python允许同时为多个变量赋值

a,b,c = 1,2,'aaa'

基础数据类型

python3中有6个标准的数据类型：使用type()函数可以查看变量所指的数据类型。

不可变数据类型：Number(数字),String(字符串),Tuple(元组)        可变数据类型：List(列表),Dictionary(字典),Set(集合)

一、Number（数字）

int:计算机是二进制，所以有时候用十六进制表示整数比较方便，十六进制用"0x"前缀和0-9，a-f表示，例如：0xff20,0xa3d53,等等。

float：浮点数是因为使用科学计数法的话，小数点位置是可以变动的，比如1.23*10²=12.3*10，对于很大/很小的浮点数，必须用科学记数法表示，10用e表示，1.23*10⁸=1.23e8

或者12.3e7,同理，0.0123可以写作1.23*e-2。

注意：整数和浮点数在计算机内部存储的方式不同，整数运算永远是精确的，浮点数在运算的时候可能会由于四舍五入造成一些误差。

bool：True/False

complex：python支持复数a+bj，a:实部，b：虚部或者complex(a,b)，a,b均为浮点型。

二、String (字符串)

字符串用单引号 ' 或双引号 " 括起来，可以使用反斜杠 \ 转义特殊字符。

截取 例：str[1:2]  顾首不顾尾；+ 是字符串的拼接，* 是字符串的复制，*N为复制N次。

转义字符 \ 可以转义很多字符，\n表示换行，\t表示制表符，\本身也要转义就是 \\

如果一个字符串里的所有字符都不需要转义可以用 r '字符串'，内部字符不转义

print('hello\n12\t3')
print(r'hello\n123')
print('I\'m"123\tOK"')

三、Tuple (元组) 

元组与列表非常类似，数据不可改变。不可变的tuple的意义就在于代码更加安全。

不过tuple里面如果含有列表，列表的内容是可以修改的，这就造成了一种假象：即tuple可以”改变“。tuple的不变是指每个元素的指向不变，请不要混淆。

理解了”指向不变“后，如果想创建一个内容也不变的元组怎么办呢？那就需要tuple的每个元素本身也不可变。

tuple的歧义：

t2 = (1)#错误定义，定义的不是元组，是1这个数字，产生了歧义
print(t2)
t1 = (1,)#正确定义，加个“，”来消除歧义
print(t1) #显示也会有一个“，”,以免误解成数学计算意义上的括号

四、List (列表) 

列表简介

a = [1,2,3,4,5]
a[0] = 4#改变数据
a[0:2] = [7,8]#改变数据
a[0:3] = [] #选取的内容设为空

列表值可以改变,索引，截取，拼接，重复等

列表增加

append()增加，insert()增加

list = ['a','b','c']#创建列表
print(len(list))#可以用len获取列表的元素个数
print(list[0])#用索引访问列表的元素，超出范围会报错
list.append('d')#使用append()方法向列表中添加元素，默认添加到列表尾部
print(list)
list.insert(0,'e')#还可以用insert()添加到指定的位置
print(list)

索引插入

索引某个元素，插入其前面

employee = ['a','f','d','s']
employee.insert(employee.index('d'),'我在d的前面')
print(employee)

extend()

迭代增加----iterable 可迭代的 

list1 = ['a','f','d','w','e']
list1.extend('三字经')#拆分到元素进行迭代增加（字符串）
print(list1)
list2 = ['a','f','d','w','e']
list2.extend([1,2,3,'三字经',[1,2,3]])#观察运行结果进行对比分析（列表），实现了列表的合并
print(list2)

列表删除

pop()

list.pop() #删除列表末尾的元素，only once
print(list)

list.pop(0) #删除列表指定位置的元素
print(list)

.remove()

删除列表元素

list = ['a','b','c']
list.remove('b')#删除指定的元素
print(list)

.clear()

清空列表

list = ['a','b','c']
list.clear()#清空列表
print(list)

del list

删除列表

list1 = ['a','b','c']
del list1
print(list1)

切片删除

list1 = ['a','b','c','d','e']
del list1[2:]
print(list1)

 列表改：

s = ['a','f','d','w','e']
s[0] = '1'#用赋值去改
print(s)
s[0:2] = '123'#切片迭代,同extend
print(s)
s[0:2] = [1,2,3,4,5,['aa','bb']]
print(s)

排序

.sort()

 

list1 = ['a','f','d','w','e']
print(list1.sort())#无法排序，输出none

list1.sort()#正确输出,默认升序
print(list1)
list1.sort(reverse=True)#降序排序,reverse默认为False
print(list1)

l2 = sorted(list1)#临时排序
print(l2)

list1 = ['a','f','d','w','e']
list1.reverse()#反转输出
print(list1)

列表嵌套

前面有说到。列表可以存储不同的数据类型，比如列表里面包含了另一个列表，那要如何访问呢？

list2 = ['c','d','e']
list1 = ['a','b',list2]
print(list1)
print(list1[2][0])

这样的情况可以看成是一个二维数组，当然，也有，三维、四维..数组等，不过用到的很少。

五、Dictionary (字典)

字典简介

列表是有序的对象集合，字典是无序的对象集合。

两者的区别之处在于：字典中的元素是通过键来存取的，而不是通过偏移存取。

字典是一种映射的类型，用大括号"{}"表示。他是一个无序的  键(key) : 值(value)  对集合,键值key必须用不可变数据类型，同一个字典中键唯一。

内置函数有clear()：清空字典内的所有数据keys(),values()

字典基本操作

创建、增加、输出、keys(),values()

dict = {}#创建空字典
dict['name'] = 'Gruffalo' #空字典添加数据
dict['age'] = '21'
print(dict)
print(dict['name'])
print(dict['age']*8)
info = {'name':'polar-bear','age':'4','location':'north pole'}
print(info)
print(info.keys())#显示所有键
print(info.values())#显示所有值

补充：items()

dic1 = {'age':1,'name':'siri','sex':'male'}
print(dic1.items())
#用两个参数搭配for循环进行格式化输出
for k,v in dic1.items():
    print(k,v,end=' *//分割线//* ')#end可以平常随意练习

 增改+1

dic1 = {'age':1,'name':'siri','sex':'male'}
dic1['location'] = 'beijing'#无则增
print(dic1)
dic1['location'] = 'shanghai'#有则改
print(dic1)

.setdefault()方法

dic1 = {'age':1,'name':'siri','sex':'male'}
dic1.setdefault('name')
print(dic1)
dic1.setdefault('location')#没有就添加key，默认value为None
print(dic1)
dic1.setdefault('living','beijing')
print(dic1)

.pop()方法

dic1 = {'age':1,'name':'siri','sex':'male'}
print(dic1)
print(dic1.pop('age'))#指定key去删除，默认返回值value
print(dic1)
print(dic1.pop('age','成功删除'))#指定key去删除，可自定义返回值
print(dic1)

popitem()

dic1 = {'age':1,'name':'siri','sex':'male'}
print(dic1.popitem())#有返回值，返回的元组里面是键值对
print(dic1)
print(dic1.popitem())#有返回值，返回的元组里面是键值对
print(dic1)
#经测，是为随机删除，当前python版本为python3.5.4

del函数

dic1 = {'age':1,'name':'siri','sex':'male'}
del dic1['age']#根据key删除键值对
print(dic1)
del dic1['location']#删除不存在key会报错
print(dic1)

dic1 = {'age':1,'name':'siri','sex':'male'}
dic1.clear()#清空字典
print(dic1)
dic1 = {'age':1,'name':'siri','sex':'male'}
del dic1#删除字典
print(dic1)

.update

dic1 = {'age':1,'name':'siri','sex':'male'}
dic2 = {}
dic2.update(dic1)
print(dic1)
print(dic2)#空字典dict2完全复制字典dict1的所有内容

dic1 = {'age':1,'name':'siri','sex':'male'}
dic3 = {'age':20,'location':'beijing'}
print(dic1)
print(dic3)
dic3.update(dic1)
print(dic3)
#可以看到，具有相同key的，value被覆盖，没有的则添加进去

 遍历输出方式

dic1 = {'age':1,'name':'siri','sex':'male'}
for i in dic1:
    print(i)#默认按key进行输出
for i in dic1.keys():
    print(i)
for i in dic1.values():
    print(i)

如果key不存在的话，就会报错：（引发异常）

info['job']

想要避免报错的话，有两种方法：

1，通过用in 判断key是否存在

print('job' in info)

2，通过dict内置方法get(),如果key不存在，返回none，当然，你也可以自定义返回值

print(info.get('job'))
print(info.get('job','key不存在'))

dict的嵌套

dic = {
    'name':['python','java','c'],
    'web':{
        'html':'123',
        'css':'456',
        'js':'233'
    },
    'location':'beijing'
}
print(dic)
#把location值改为shanghai
dic['location'] = 'shanghai'
print(dic)

dic = {
    'name':['python','java','c'],
    'web':{
        'html':'123',
        'css':'456',
        'js':'233'
    },
    'location':'beijing'
}
print(dic)
#在name 键的value增加一个SQL
dic['name'].append('SQL')
print(dic)

dic = {
    'name':['python','java','c'],
    'web':{
        'html':'123',
        'css':'456',
        'js':'233'
    },
    'location':'beijing'
}
print(dic)
#以下是自己错误使用方法，append()没有返回值,sort(),reverse也是
dic['name'] = dic['name'].append('test')
print(dic)
#sort,reverse也无返回值
s = [1,3,5,2,8,4,6]
print(s.sort())
print(s.reverse())

dic = {
    'name':['python','java','c'],
    'web':{
        'html':'123',
        'css':'456',
        'js':'233'
    },
    'location':'beijing'
}
print(dic)
#把java变成大写
dic['name'][1] = dic['name'][1].upper()
print(dic)
#web里面再添加一键值对'go':'999'
dic['web']['go'] = '999'
print(dic)

dict和list的比较：

dict:1，插入和查找的速度很快，不会随着key的增加而减慢；2，需要占用大量的内存，浪费内存。

list: 1，插入和查找的速度随着元素的增加而增加；2，占用空间小，浪费内存少。

所以，dict是用空间换取时间的一种方法。

六、Set (集合)

set简介

set和dict类似，也是一组key的集合，但没有存储value。由于key值不能重复，所以，在set中，没有重复的key。

s1 = set([1,2,3,4])#创建一个set，需要提供一个list作为输入集合
print(s1)
s2 = set([1,2,2,3,3,5,6,4,2,8,1])#自动过滤重复值
print(s2)

set的基本操作

add()

通过add()方法可以添加元素到set中，可以添加重复的值，但不会有效果。

s1.add(5)
print(s1)
s1.add(2)
print(s1)

update迭代增加

int类型不可迭代

set1 = {1,2,3,4,5}
set1.update('我爱中国')
print(set1)

pop

{1,2,3,4,5,'a','b'}
set1.pop()#随机删除
print(set1)

clear

 {1,2,3,4,5,'a','b'}
set1.clear()#清空集合
print(set1)

del

3,4,5,'a','b'}
del set1#删除集合
print(set1)

remove()

通过remove()方法可以删除元素。

s1.remove(5)
print(s1)

集合运算

可以看成数学上的集合，可以进行相应的集合运算

s1 = set([1,2,3,4])
s2 = set([1,2,2,3,3,5,6,4,2,8,1])
print(s1 - s2)#差集
print(s2 - s1)#差集
print(s2 | s1)#并集
print(s2 & s1)#交集
print(s1 ^ s2)#不同时存在的元素，不要与差集进行混淆

子集与超集

,2,3,4,5}
set2 = {1,2,3,4,5,'a','b'}
print(set1 < set2)#判断set1 是否是 set2的子集
print(set1.issubset(set2))

print(set2 > set1)#判断set2 是否是 set1的超集
print(set2.issuperset(set1))

frozenset

frozenset不可变集合，让集合变成不可变类型。

s = frozenset('好好学习天天向上')
print(s,type(s))

成员测试

s1 = set([1,2,3,4])#观察两个集合区别
if 1 in s1:#引号疑惑（列表元素无引号为整数，不属于字符串，所以条件语句也不能加引号）
    print('1'+'在集合中')
else:
    print('1'+'不在集合中')
a = set('abracadabra')
if 'a' in a:#引号疑惑（字符串引号）
    print('yes')
else:
    print('no')

pass