python自学笔记（2）--数据类型

python自学笔记（2）--数据类型

Python核心数据类型：
1. 数字：int long float complex（复数） bool
2. 字符：str Unicode ‘’   
3. 列表：list []
4. 字典：dict {}
5. 元组：tuple ()
6. 文件：file
7. 其他类型：set（集合{}） frozenset（冻结集合，不可变的） 类类型（类本身也是一种数据类型） None（空） 
其他文件类工具：pipes（管道） fifos（先进先出管道） sockets（套接字）

类型转换：
1.字符串转换：str() repr() format():三个都可以将飞字符型数据转换成字符型，转换后的结果不会被存下来，必须进行引用才能存储下来（原对象是不可变类型，所以原对象不会发生变化）。
str转换的输出与print一样。
repr对某个对象的精确值；总而言之，str出来的值是给人看的字符串，repr出来的值是给机器看的，括号中的任何内容出来后都是在它之上再加上一层引号。
format利用特定格式转换字串。

print(str("Hello, world!"))#ello, world!
print(repr("Hello,  world!"))#'Hello,  world!'

# format用法：参数可以是位置参数，也可以是关键字参数,位置参数需要在关键字参数之前定义。
print('{0} love {1}'.format("i", "you"))  # i love you
print("{0:.2f}{unit}".format(12.288, unit="GB"))  # 12.29GB
print("{num:.2f}{unit}".format(num=12.288, unit="GB"))  # 12.29GB

2.数值转换：int() float() 
3.列表转换：list() 可以将字串转换成列表，反过来列表转字串的操作其实是不太方便的。

str1 = "hello Jimmy!"
l1 = list(str1)
print(l1) #'h', 'e', 'l', 'l', 'o', ' ', 'J', 'i', 'm', 'm', 'y', '!']

4.Tuple(str):将字串转换成元组

str1 = "hello Jimmy!"
t1 = tuple(str1)
print(t1)#('h', 'e', 'l', 'l', 'o', ' ', 'J', 'i', 'm', 'm', 'y', '!')

5.set（str）将字串转成集合（set是没有次序的）

str1 = "hello Jimmy!"
ss1 = set(str1)
print(ss1)#{' ', 'h', '!', 'm', 'l', 'e', 'i', 'J', 'y', 'o'}

6. dict（d）：创建字典，d必须是键值对（key，value）序列，注意字典是也是没有次序的。但是创建出来的顺序确实是跟列表顺序一致，需要进一步确认

l1 = [('a',1),('b',2),('c',3),('d',4),('f',6),('e',5)]
d1 = dict(l1)
print(d1)#{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'f': 6, 'e': 5}

7.floatset(str):将字串转成不可变集合

str1 = "hello Jimmy!"
ss1 = set(str1)
ss2 = frozenset(str1)
print(ss1) #可以看出，set无序，并且无重复元素{'e', 'm', 'l', '!', 'y', 'J', 'h', 'i', 'o', ' '}
print(ss2) #frozenset({'e', 'm', 'l', '!', 'y', 'J', 'h', 'i', 'o', ' '})

8.chr(x):将数字转成单个字符

i = 97
print(chr(i))#a

9.ord(x):将字符转成整数值

c1 = 'a'
print(ord(c1))#97

10.bin(x):转成二进制字串

i = 10
print(bin(i))#0b1010

11.oct(x):转成八进制字串

i = 10
print(oct(i))#0o12

数字类型（不可变类型）：

Python的数字字面量：布尔 整形，浮点，复数
True 1（首字母大写，不同于java）
False 0（首字母大写，不同于java）

数字支持的操作有：

操作	描述	操作	描述
x+y	加法	x**y	乘方（x的y次方）
x-y	减法	x%y	取模
x*y	乘法	-x	一元减法
x/y	除法	+x	一元加法
x//y	截断除法

需要指出的是：

    Python的传统除法运算符（有小数部分）是 / ，地板除法运算符（取整数部分）是 //

数字的比较运算有：

操作	描述	操作	描述
x<<y	左移操作	x|y	按位或
x>>y	右移操作	x^y	按位异或
x&y	按位与	~x	取反操作

字符类型：

将文本放入单引号，双引号或者三引号。如果使用unicode编码，需要在字符前加u，如str1 = u"hello world!"
文档字串：模块或者类或者函数的第一条语句，使用__doc__引用。
加括号表示调用对象方法，不加括号表示引用对象本身

def printName():
    "ddddfdfdf"
    print("Hello world!")
printName()
print(printName.__doc__)

s[i]:索引运算符
s[i:j]:切片运算符，j是不显示的
s[i:j:stride]:扩展运算符，j是不显示的，i和j和stride可以是负数

str1 = "abcdefghijklmn"
str2 = str1[6:0:-2]#从6到0，但是不包括0，步长为-2，往回跳
print(str2)# gec

min() max()取字串中的最小值和最大值，参考assci码
all(s) 检查s中所有项是否为True，同样可用于判断元组或列表
any(s) 检查s中任意项是否为True，同样可用于判断元组或列表
https://www.cnblogs.com/nulige/p/6128816.html
http://blog.csdn.net/kuaileboy1989/article/details/45075431

列表类型：
它是一个容器类型。内部包含任意对象的有序集合，通过索引访问其中的元素，长度可变，支持嵌套，支持异构（可包含多种不同类型的元素）
支持元素替换，去除等操作，原处修改，不会返回任何结果新列表
        列表的pop()方法，传递的是待删除元素的index，remove()传递待删除元素本身，如果多个元素一样，默认删除第一个。

l2 = [[1,2,3],('a','b','c'),"def",4,5,6,{(12,14),12,13,"gg"}]
l3 = ['d','e','f']
l2.insert(0,"haha")#指定位置插入
l2[1] = 9#同其他切片层次修改一样，改的是元素
del(l2[2])
l2.append(l3)
l2.pop(2)#弹出第二个元素，“def”
print(l2)# ['haha', 9, 'def', 4, 5, 6, {13, 12, (12, 14), 'gg'}, ['d', 'e', 'f']]
print(l2.count(6))#只能看数出现的次数，结果是1

相加操作l1 + l2，是合并列表，并且返回一个新列表，需要付给新的列表变量才能进行后续操作。（字串也是类似的，相加后返回新串）
l1 * N，把l1重复N次，返回一个新列表。
in （not in）成员关系判断字符，在制定容器中是否出现了制定元素，用法为object in container。

l3 = ['d','e','f']
print('d' in l3)#True

列表的复制方式

import copy
l1 = [1,2,3]
l2 = l1#浅copy
l3 = l1[:]#复制所有元素到l3
l4 = copy.deepcopy(l1)#深度copy
l1.append(4)
print(l2)#[1, 2, 3, 4]
print(l3)#[1, 2, 3]
print(l4)#[1, 2, 3]

列表的升序和翻转

l1 = [1,2,3,6,7,9,4,5,6]
l1.sort()#原处升序
print(l1)#[1, 2, 3, 4, 5, 6, 6, 7, 9]
l1.reverse()#原处翻转，实现降序
print(l1)#[9, 7, 6, 6, 5, 4, 3, 2, 1]

元组：
表达式符号：（），定义时括号可以省略。
支持异构，也是容器类型，任意对象的有序集合，通过所以访问，是不可变对象（但里面如果包含可变对象，如列表，是可以修改的），长度固定，支持嵌套。
相加生成新元组，t1 * N也生成新元组，可使用in 和not in判断是否包含某些元素

t1 = (1,2,3,[4,5],(6,7),4)
t2 = 'x','y','z'
t3 = t1 + t2
print(t3)# (1, 2, 3, [4, 5], (6, 7), 4, 'x', 'y', 'z')

字典：

dict {key1:value,key2:value2,…}又称为关联数组或散列表。无序的集合，可变类型容器，长度可变，支持异构和嵌套。

方法get，items（将字典转化为元组列表）

d1 = {'a':1,'b':2,'c':3,'d':4}
print(d1.items())#dict_items([('a', 1), ('b', 2), ('c', 3), ('d', 4)])

t1,t2,t3,t4 = d1.items()#前后个数需要一致
print(t1)#('a', 1)
print(t2)#('b', 2)
print(t3)#('c', 3)
print(t4)#('d', 4)

print(d1.keys())#dict_keys(['a', 'b', 'c', 'd'])
print(d1.values())#dict_values([1, 2, 3, 4])
#P.S. 在python3中使用dict.keys()或者.values()返回的不在是list类型了，也不支持索引,如果想支持索引，需要额转成list，比如list(d1.keys())

********************************************************************************

d1 = {'a':1,'b':2,'c':3,'d':4}
# d1.pop('e')#wrong
d1.pop('b')#{'a': 1, 'c': 3, 'd': 4}
print(d1)

*******************************************************************************

d1 = {'x':1,'y':2}
d2 = {'m':1,'n':2,'y':55}
d1.update(d2)#字典的更新
print(d1)#{'x': 1, 'y': 55, 'm': 1, 'n': 2}

*********************************************************************************

d1 = {'a':1,'b':2,'c':3,'d':4}
i1 = d1.items()#dict_items([('a', 1), ('b', 2), ('c', 3), ('d', 4)])
print(i1)
for k,v in i1:
    print(k,v)
#a 1
# b 2
# c 3
# d 4

**********************************************************************************

print(list(zip('xyz','123','abc')))#[('x', '1', 'a'), ('y', '2', 'b'), ('z', '3', 'c')]使用zip快速生成list
print(dict(zip('xyz','123')))#{'x': '1', 'y': '2', 'z': '3'}使用zip快速生成字典

********************************************************************************

l1 = [0, 1, 2, 3, 4, 5, 6]
l2 = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat']
d1 = {}
for i in range(l1.__len__()):
    d1.setdefault(l1[i],l2[i])# Python 字典 setdefault() 函数和get() 方法类似, 如果键不存在于字典中，将会添加键并将值设为默认值。S
#生成字典可以直接赋值进行，比如d1[0] = Sun,字典支持直接修改
else:
    print(d1)

p.s. python中获取帮助的方法
print(dir(list))#['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__',
# '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__',
# '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__',
#  '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__',
#  '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__',
# '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert',

# 'pop', 'remove', 'reverse', 'sort']

print(help(list.pop))#Help on method_descriptor:
            #
            # pop(...)
            #     L.pop([index]) -> item -- remove and return item at index (default last).
            #     Raises IndexError if list is empty or index is out of range.
            #
            # None

集合：set() frozenset()。

无特定语法格式，只能通过工厂函数创建。集合是一组无序排列，可哈希的值，支持数学中的集合关系测试（交集，并集，包含，被包含，差集）；不支持元素索引，不支持获取操作，set是可变的，比如支持pop操作。

l1 = [1,2,3,6,7,9,4,5,6,5,4,3,2,1,0]
d1 = {'a':1,'b':2,'c':3,'d':4}
s1 = set(l1)
s2 = set(d1)
print(s1)#{0, 1, 2, 3, 4, 5, 6, 7, 9},不含重复元素
print(s2)#{'d', 'a', 'b', 'c'}，无序，默认反馈keys的集合
s3 = set(d1.values())
print(s1 & s3) #{1, 2, 3, 4}
print(s1 | s3) #{0, 1, 2, 3, 4, 5, 6, 7, 9}

**********************************************************************************

l1 = [1,2,3,6,7,9,4,5,6,5,4,3,2,1,0]
d1 = {'a':1,'b':2,'c':3,'d':4}
s1 = set(l1)
s2 = set(d1)
s2.update(s1)
print(s2)# {0, 1, 2, 3, 4, 5, 6, 7, 9, 'd', 'c', 'b', 'a'}

P.S.所有序列都支持迭代。所有序列都支持的操作和方法  索引，切片，扩展切片，len，min，max，all，any，sum，s1 +s2, s1 *N,obj in s1, obj not in s1。

P.S.  sys.getrefcount函数

python所有对象都有引用计数，当前数据对象赋值给某个变量时，则变量引用了该数据对象。

python采用"引用计数"和"垃圾回收"两种机制来管理内存。该函数可用于判断是否存在内存溢出，具体没有详细调查，该值一般不会为0。

import sys
jimmy = "a"
print(sys.getrefcount(jimmy))