Python Data Type

Python 数据类型：哈希类型、不可哈希类型

• 数字类型：int, float, decimal.Decimal, fractions.Fraction, complex
• 字符串类型：str, bytes
• 元组：tuple
• 冻结集合：frozenset
• 布尔类型：True, False
• None
• 哈希类型， 即在原地不能改变的变量类型， 不可变类型。可利用hash函数查看其hash值， 也可以作为字典的key。

• 不可hash类型：原地可变类型：list 、dict 和 set。它们不可以作为字典的key。

 数字常量

• 1236， -1236， 0， 999999999　　　　　　　　　 # 整数
• 1.2， 1. ，3.1415926， 3.14e-10， 4E2, 4.0e+5　　# 浮点数

>>> 3.14e-10
3.14e-10
>>> '{:.15f}'.format(3.14e-10)
'0.000000000314000'
>>> 4E2
400.0
>>> 4.0e+5
400000.0
>>> 

• 0o177　　  #  八进制（0o开头）
• 0x9ff　　    # 十六进制（0x开头）
• 0b1010　　# 二进制数字（0b开头）

>>> 0o177        # 1 * 8**2 + 7 * 8**1 + 7 * 8**0  == 127
127
>>> 0x9ff        # 9 * 16**2 + 15 * 16**1 + 15 * 16**0 == 2559
2559
>>> 0xFF         # 不区分大小写（A:10, B:11, C:12, D:13, E:14, F:15）
255
>>> 0b1010       # 1 * 2**3 + 1 * 2**1  == 10
10
>>> 

• oct(I)　　# 将十进制（decimal ）转化成八进制（octal）表示的“字符串”
• hex(I)　   # 将十进制（decimal ）转化成十六进制（hexadecimal）表示的“字符串”
• bin(I) 　　# 将十进制（decimal ）转化成二进制（binary）表示的“字符串”

>>> oct(255)
'0o377'
>>> hex(255)
'0xff'
>>> bin(255)
'0b11111111'
>>> 

int(string, base)　　# 将字符串转化成整数， base为字符串所代表的进制数，

　　　　　　　　　　　　 # 可以将表示其他进制的数的字符串转化成十进制的整数

>>> int('0o377', base = 8)
255
>>> int('0xff', base = 16)
255
>>> int('0b11111111', 2)
255
>>> 

3+6j, 3.0+6.0j, 3J　　# 附属常量， 也可以用 complex(real, image) 来创建

>>> type(3+6j)
<class 'complex'>
>>> type(3.0+6.0j)
<class 'complex'>
>>> type(3J)
<class 'complex'>
>>> 
>>> a = complex(3, 6)
>>> a
(3+6j)
>>> 

2.x中，有两种整数类型：

1. 一般整数（32位）;
2. 长整数（无穷精度）。可以用l 或 L 结尾，迫使一般整数成为长整数

>>> a = 2 ** 30
>>> a
1073741824
>>> type(a)
<type 'int'>
>>>
>>> b = 2 ** 31
>>> b
2147483648L
>>> type(b)
<type 'long'>
>>>

整数可以利用 bit_length 函数测试用二进制表示所占的位数：

　　a = 1 ;　　　　a.bit_length()　　　　#  1

　　b = 2 ;　　　　b.bit_length()　　　　#  2

　　c  = 3;　　　　c.bit_length()　　　　#  2

　　d = 4;　　　　 d.bit_length()　　　　#  3

　　e = 1024;　　  e.bit_length()　　　　#  11

>>> a = 1
>>> a.bit_length()
1
>>> b = 2
>>> b.bit_length()
2
>>> c = 3
>>> c.bit_length()
2
>>> d = 4
>>> d.bit_length()
3
>>> e = 1024
>>> e.bit_length()
11
>>> 

 布尔类型 bool : True (真）， False(假）

• int  --->  bool   :   0 ---> False;   非0   ---> True
• bool  ---> int    :   False  ---> 0;  True  --->  1

>>> type(True)        　　  # 返回<class 'bool'>
<class 'bool'>
>>> type(False)            # 返回<class 'bool'>
<class 'bool'>
>>> isinstance(False, int) # bool 类型属于整形，所以返回True
True
>>> True == 1, True is 1   # 输出(True, False)
(True, False)
>>> 

• str   --->  bool  :   (Null)     ---> False;        不是Null     ---> True
• list  --->  bool  :   元素为空 ---> False;       元素不为空 ---> True

>>> a = ''
>>> bool(a)
False
>>> b = 'f'
>>> bool(b)
True
>>> 
>>> lst = []
>>> type(lst)
<class 'list'>
>>> bool(lst)
False
>>> lst = ['a']
>>> type(lst)
<class 'list'>
>>> bool(lst)
True
>>> 

常见字符串常量和表达式

• S1 = ''　　　　　　　　　　   # 空字符串
• S2 = "Today's good day"　　# 双引号和单引号同时使用
• S3 = "s p a x00 m"　　   # 转义字符
• S4 = '''docment'''　　　　　  # 三重引号字符串，一般用于函数说明
• S5 = r' emp'　　　　　　　  # Raw字符串，不会进行转义，抑制转义
• S6 = b'101100'　　　　　　   # Python3中的字节字符串
• S7 = u'0x4EFA'　　　　　     # Python2.x 中的Unicode字符串

>>> S1 = ''                    # 空字符串
>>> S2 = "Today's good day"    # 双引号和单引号同时使用
>>> S3 = "s
 p 	 a x00 m"   # 转义字符
>>> S4 = '''document'''        # 三重引号字符串，一般用于函数说明
>>> S5 = r'	emp'              # Raw字符串，不会进行转义，抑制转义
>>> S6 = b'101100'             # Python3中的字节字符串
>>> print(S1, type(S1))
 <class 'str'>
>>> print(S2, type(S2))
Today's good day <class 'str'>
>>> print(S3, type(S3))
s
 p      a   m <class 'str'>
>>> print(S4, type(S4))
document <class 'str'>
>>> print(S5, type(S5))
	emp <class 'str'>
>>> print(S6, type(S6))
b'101100' <class 'bytes'>
>>> 

>>> S7 = u'0x4EFA'               # Python2.6中的Unicode字符串
>>> print(S7, type(S7))
(u'0x4EFA', <type 'unicode'>)
>>>

>>> S7 = u'0x4EFA'
>>> print(S7, type(S7))
0x4EFA <class 'str'>
>>> 

• S2[1], S2[-1], S2[:3], len(S2)　　　　  # 字符串操作
• 'a %s parrot' % 'kind'　　　　　　　   # 字符串格式化表达式
• 'a {1} {0} parrot'.format('kind', 'red')    # 字符串格式化方法

>>> S2[1], S2[-1], S2[:3], len(S2)
('o', 'y', 'Tod', 16)
>>> print('a %s parrot' % 'kind')
a kind parrot
>>> print('a {1} {0} parrot'.format('kind', 'red') )
a red kind parrot
>>> 

内置str处理函数：

• 对于不变对象来说，调用对象自身的任意方法，也不会改变该对象自身的内容。
• 相反，这些方法会创建新的对象并返回，这样，就保证了不可变对象本身永远是不可变的。

1. upper();   lower();　　# 全部大写，全部小写
2. swapcase();　　         # 大小写转换
3. capitalize();  title()　　# 每个单词的首字母都大写

>>> str1 = "stringOfobjectTest"
>>> str1.upper()
'STRINGOFOBJECTTEST'
>>> str1.lower()
'stringofobjecttest'
>>> str1.swapcase()
'STRINGoFOBJECTtEST'
>>> str1.capitalize()
'Stringofobjecttest'
>>> "LIFE IS SHORT, USE PYTHON".title()
'Life Is Short, Use Python'
>>>

1. ljust(width) 　　       # 获取固定长度，左对齐，右边不够用空格补齐
2. rjust(width) 　　       # 获取固定长度，右对齐，左边不够用空格补齐
3. center(width[,'*'])      # 获取固定长度，中间对齐，两边不够用空格补齐,可指定填充字符
4. zfill(width)                 # 获取固定长度，右对齐，左边不足用0补齐

>>> "infor".ljust(20)        # 获取固定长度，左对齐，右边不够用空格补齐
'infor               '
>>> "infor".rjust(20)        # 获取固定长度，右对齐，左边不够用空格补齐
'               infor'
>>> "infor".center(20)       # 获取固定长度，中间对齐，两边不够用空格补齐
'       infor        '
>>> "infor".center(20, '*')  # 可指定填充字符
'*******infor********'
>>> "682.6".zfill(20)        # 获取固定长度，右对齐，左边不足用0补齐
'000000000000000682.6'
>>> 

1. find('a',start,end)      # 查找字符串，可以指定起始及结束位置搜索
2. rfind('a')                     # 从右边开始查找字符串
3. index('a',start,end)   # 使用index查找不到会抛异常，而find返回-1
4. count('a')                   # 查找字符串出现的次数

>>> S2
"Today's good day"
>>> S2.find('a')           # 查找字符串，可以指定起始及结束位置搜索
3
>>> S2.find('a', 4, -1)    # 查找字符串，可以指定起始及结束位置搜索
14
>>> S2.rfind('a')          # 从右边开始查找字符串
14
>>> S2.index('a', 4)       # 查找字符串，可以指定起始及结束位置搜索
14
>>> S2.count('a')          # 查找字符串出现的次数
2
>>> S2.find('n')           # 找不到，find返回-1
-1
>>> S2.index('n')          # 使用index查找不到会抛异常，而find返回-1
Traceback (most recent call last):
  File "<pyshell#62>", line 1, in <module>
    S2.index('n')
ValueError: substring not found
>>> 

1. replace('old','new')     # 替换函数，替换old为new，参数中可以指定maxReplaceTimes，即替换指定次数的old为new
2. strip();                          # 默认删除空白符
3. strip('d');                      # 删除Str1字符串中开头、结尾处，位于 d 删除序列的字符
4. lstrip();
5. lstrip('d');                     # 删除Str1字符串中开头处，位于 d 删除序列的字符
6. rstrip();
7. rstrip('d')                      # 删除Str1字符串中结尾处，位于 d 删除序列的字符

>>> Str1 = '  --- we all like beautiful woman woman woman. ***   '
>>> Str1.replace('woman', 'girl')
'  --- we all like beautiful girl girl girl. ***   '
>>> Str1.replace('woman', 'girl', 2)
'  --- we all like beautiful girl girl woman. ***   '
>>> Str1.lstrip()
'--- we all like beautiful woman woman woman. ***   '
>>> Str1.lstrip(' -')
'we all like beautiful woman woman woman. ***   '
>>> Str1.rstrip()
'  --- we all like beautiful woman woman woman. ***'
>>> Str1.rstrip(' *')
'  --- we all like beautiful woman woman woman.'
>>> Str1.strip()
'--- we all like beautiful woman woman woman. ***'
>>> Str1.strip(' -*')
'we all like beautiful woman woman woman.'
>>> 

1. str1.startswith('start') 　　　　　　　  # 是否以start开头
2. str1.endswith('end') 　　　　　　 　　# 是否以end结尾
3. str1.isalnum(); 　　　　　　　　　　  # 判断字符串是否全为字符和数字
4. str1.isalpha();  str1.isdigit(); 　　　　  # 判断字符串是否全为字符、数字
5. str1.islower();  str1.isupper() 　　　　 # 判断字符串是否全为小写、大写

>>> str1 = "A red-black tree is a binary search tree with one extra bit of storage per node: it's color, which can be either RED or BLACK."
>>> str1.startswith('A red-black tree')
True
>>> str1.endswith('BLACK')
False
>>> str1.isalnum()
False
>>> str1.isalpha()
False
>>> str1.isdigit()
False
>>> str1.islower()
False
>>> str1.isupper()
False
>>> 'Ared-blacktreeisabinarysearchtree666'.isalnum()
False
>>> 'Aredblacktreeisabinarysearchtree666'.isalnum()
True
>>> 'Aredblacktreeisabinarysearchtree'.isalpha()
True
>>> '123456  '.isdigit()
False
>>> '123456'.isdigit()
True
>>> 'AREDBLACKTREEISABINARYSEARCHTREE'.isupper()
True
>>> 'aredblacktreeisabinarysearchtree'.islower()
True
>>>