python 基本类型的创建方法

1、int

class int(object)
 |  int(x=0) -> integer
 |  int(x, base=10) -> integer
 | 
 |  Convert a number or string to an integer, or return 0 if no arguments
 |  are given.  If x is a number, return x.__int__().  For floating point
 |  numbers, this truncates towards zero.
 | 
 |  If x is not a number or if base is given, then x must be a string,
 |  bytes, or bytearray instance representing an integer literal字面 in the
 |  given base.  The literal can be preceded在什么之前 by '+' or '-' and be surrounded环绕
 |  by whitespace.  The base defaults to 10.  Valid bases are 0 and 2-36.
 |  Base 0 means to interpret the base from the string as an integer literal.
 |  >>> int('0b100', base=0)
 |  4

# 1、没有参数转换为0
print(int())
print('*' * 50)

# 2、一个数字转换为整数
print(int(10.6))
print('*' * 50)

# 3、将一个字符串转换为整数
print(int('111', 16))
print(int('111', 10))
print(int('111', 8))
print(int('111', 2))
print('*' * 50)

# 4、将一个字节流或字节数组转换为整数
print(int(b'111', 16))
print(int(b'111', 10))
print(int(b'111', 8))
print(int(b'111', 2))
print('*' * 50)

# 5、base=0时，按字面值进行转换
print(int('0x111', 0))
print(int('111', 0))
print(int('0o111', 0))
print(int('0b111', 0))
print('*' * 50)

0
**************************************************
10
**************************************************
273
111
73
7
**************************************************
273
111
73
7
**************************************************
273
111
73
7
**************************************************

2、bool

class bool(int)                                                              
 |  bool(x) -> bool                                                     
 | 
 |  Returns True when the argument x is true, False otherwise.                   
 |  The builtins True and False are the only two instances of the class bool.   
 |  The class bool is a subclass of the class int, and cannot be subclassed. 

3、float

class float(object)
 |  float(x) -> floating point number
 | 
 |  Convert a string or number to a floating point number, if possible.

print(float(123))
print(float('123'))

123.0
123.0

4、str

class str(object)
 |  str(object='') -> str
    # 对象转字符串
 |  str(bytes_or_buffer[, encoding[, errors]]) -> str
    # 字节流转字符串
 | 
 |  Create a new string object from the given object. If encoding or
 |  errors is specified, then the object must expose a data buffer
 |  that will be decoded using the given encoding and error handler.
 |  Otherwise, returns the result of object.__str__() (if defined)
 |  or repr(object).
 |  encoding defaults to sys.getdefaultencoding().
 |  errors defaults to 'strict'.

# 1、对象转字符串
# 如果对象存在__str__方法，就调用它，否则调用__repr__
print(str([1, 2, 3]))       # 调用了列表的__str__
print([1, 2, 3].__str__())
print(str(type))            # 调用了列表的__repr__
print(type.__repr__(type))
print('*' * 50)
# 注意
print(str(b'123456'))   # 这个是对象转字符串，不是字节流转字符串
print(b'123456'.__str__()) 
print('*' * 50)

# 2、字节流转字符串
# 第一个参数是字节流对象
# 第二个参数是解码方式，默认是sys.getdefaultencoding()
# 第三个参数是转换出错时的处理方法，默认是strict
import sys
print(sys.getdefaultencoding())
print(str(b'123456', encoding='utf-8'))    # 字节流转字符串的第一种方法
# 字节流转换字符串
print(b'123456'.decode(encoding='utf-8'))  # 字节流转字符串的第二种方法

[1, 2, 3]
[1, 2, 3]
<class 'type'>
<class 'type'>
**************************************************
b'123456'
b'123456'
**************************************************
utf-8
123456
123456

5、bytearray

class bytearray(object)
 |  bytearray(iterable_of_ints) -> bytearray<br>    
    # 元素必须为[0 ,255] 中的整数
 |  bytearray(string, encoding[, errors]) -> bytearray<br>    
    # 按照指定的 encoding 将字符串转换为字节序列
 |  bytearray(bytes_or_buffer) -> mutable copy of bytes_or_buffer<br>    
    # 字节流
 |  bytearray(int) -> bytes array of size given by the parameter initialized with null bytes<br>    
    # 返回一个长度为 source 的初始化数组
 |  bytearray() -> empty bytes array<br>    
    # 默认就是初始化数组为0个元素
 | 
 |  Construct a mutable bytearray object from:
 |    - an iterable yielding integers in range(256)          
      # bytearray([1, 2, 3])
 |    - a text string encoded using the specified encoding   
      # bytearray('你妈嗨', encoding='utf-8')
 |    - a bytes or a buffer object                           
      # bytearray('你妈嗨'.encode('utf-8'))
 |    - any object implementing the buffer API.            
 |    - an integer                                           
      # bytearray(10)

# 1、0个元素的字节数组
print(bytearray())
print('*' * 50)

# 2、指定个数的字节数组
print(bytearray(10))
print('*' * 50)

# 3、int类型的可迭代对象，值在0-255
print(bytearray([1, 2, 3, 4, 5]))
print('*' * 50)

# 4、字符串转字节数组
print(bytearray('12345', encoding='utf-8'))
print('*' * 50)

# 5、字节流转字符串
print(bytearray(b'12345'))
print('*' * 50)    

bytearray(b'')
**************************************************
bytearray(b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')
**************************************************
bytearray(b'\x01\x02\x03\x04\x05')
**************************************************
bytearray(b'12345')
**************************************************
bytearray(b'12345')
**************************************************

6、bytes

class bytes(object)
 |  bytes(iterable_of_ints) -> bytes<br>    # bytes([1, 2, 3, 4])  bytes must be in range(0, 256)
 |  bytes(string, encoding[, errors]) -> bytes<br>    # bytes('你妈嗨', encoding='utf-8')
 |  bytes(bytes_or_buffer) -> immutable copy of bytes_or_buffer<br>    #
 |  bytes(int) -> bytes object of size given by the parameter initialized with null bytes
 |  bytes() -> empty bytes object
 | 
 |  Construct an immutable array of bytes from:
 |    - an iterable yielding integers in range(256)
 |    - a text string encoded using the specified encoding
 |    - any object implementing the buffer API.
 |    - an integer

# 1、一个空字节流
print(bytes())
print('*' * 50)

# 2、一个指定长度的字节流
print(bytes(10))
print('*' * 50)

# 3、int类型的可迭代对象，值0-255
print(bytes([1, 2, 3, 4, 5]))
print('*' * 50)

# 4、string转bytes
print(bytes('12345', encoding='utf-8'))
print('*' * 50)

print('12345'.encode(encoding='utf-8'))
print('*' * 50)

# 5、bytearry转bytes

print(bytes(bytearray([1, 2, 3, 4, 5])))
print('*' * 50)

b''
**************************************************
b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
**************************************************
b'\x01\x02\x03\x04\x05'
**************************************************
b'12345'
**************************************************
b'12345'
**************************************************
b'\x01\x02\x03\x04\x05'
**************************************************

7、list

class list(object)
 |  list() -> new empty list
 |  list(iterable) -> new list initialized from iterable's items

# 1、返回一个空列表
print(list())

# 2、将一个可迭代对象转换成列表
print(list('string'))
print(list([1, 2, 3, 4]))
print(list({'one': 1, 'two': 2}))

# 3、参数是一个列表
l = [1, 2, 3, 4]
print(id(l))
l2 = list(l)    # 创建了一个新的列表，与元组不同
print(id(l2))   

[]
['s', 't', 'r', 'i', 'n', 'g']
[1, 2, 3, 4]
['one', 'two']
35749640
35749704

字典转列表：

d = {'one': 1, 'two': 2}

for i in d:
    print(i)
print('*'*50)

for i in d.keys():
    print(i)
print('*'*50)

for i in d.values():
    print(i)
print('*'*50)

for i in d.items():
    print(i)
print('*'*50)

print(list(d))
print(list(d.keys()))
print(list(d.values()))
print(list(d.items()))
print('*'*50)

print(d)
print(d.keys())
print(d.values())
print(d.items())
print('*'*50)

print(type(d))
print(type(d.keys()))
print(type(d.values()))
print(type(d.items()))
print('*'*50)

one
two
**************************************************
one
two
**************************************************
1
2
**************************************************
('one', 1)
('two', 2)
**************************************************
['one', 'two']
['one', 'two']
[1, 2]
[('one', 1), ('two', 2)]
**************************************************
{'one': 1, 'two': 2}
dict_keys(['one', 'two'])
dict_values([1, 2])
dict_items([('one', 1), ('two', 2)])
**************************************************
<class 'dict'>
<class 'dict_keys'>
<class 'dict_values'>
<class 'dict_items'>
**************************************************

8、tuple

class tuple(object)
 |  tuple() -> empty tuple
    # 创建一个空的元组
 |  tuple(iterable) -> tuple initialized from iterable's items
    # 将一个可迭代对象转成元组
 | 
 |  If the argument is a tuple, the return value is the same object.
    # 如果参数时一个元组，返回一个相同的对象

# 1、返回一个空元组
print(tuple())


# 2、将一个可迭代对象转换成元组
print(tuple('string'))
print(tuple([1, 2, 3, 4]))
print(tuple({'one': 1, 'two': 2}))


# 3、参数是一个元组
tp = (1, 2, 3, 4)
print(id(tp))
tp2 = tuple(tp)
print(id(tp2))

()
('s', 't', 'r', 'i', 'n', 'g')
(1, 2, 3, 4)
('one', 'two')    # 参数是字典的时候，返回的是键值的元组
35774616
35774616

字典转元组：

d = {'one': 1, 'two': 2}

for i in d:
    print(i)
print('*'*50)

for i in d.keys():
    print(i)
print('*'*50)

for i in d.values():
    print(i)
print('*'*50)

for i in d.items():
    print(i)
print('*'*50)

print(tuple(d))
print(tuple(d.keys()))
print(tuple(d.values()))
print(tuple(d.items()))
print('*'*50)

print(d)
print(d.keys())
print(d.values())
print(d.items())
print('*'*50)

print(type(d))
print(type(d.keys()))
print(type(d.values()))
print(type(d.items()))
print('*'*50)

one
two
**************************************************
one
two
**************************************************
1
2
**************************************************
('one', 1)
('two', 2)
**************************************************
('one', 'two')
('one', 'two')
(1, 2)
(('one', 1), ('two', 2))
**************************************************
{'one': 1, 'two': 2}
dict_keys(['one', 'two'])
dict_values([1, 2])
dict_items([('one', 1), ('two', 2)])
**************************************************
<class 'dict'>
<class 'dict_keys'>
<class 'dict_values'>
<class 'dict_items'>
**************************************************

9、dict

class dict(object)
 |  dict() -> new empty dictionary    # 空字典
 |  dict(mapping) -> new dictionary initialized from a mapping object's
 |      (key, value) pairs<br>    # dict([('one', 1), ('two', 2)])
 |  dict(iterable) -> new dictionary initialized as if via:
 |      d = {}
 |      for k, v in iterable:
 |          d[k] = v
 |  dict(**kwargs) -> new dictionary initialized with the name=value pairs
 |      in the keyword argument list.  For example:  dict(one=1, two=2)

# 1、空字典
print(dict())
print('*' * 50)

# 2、从一个映射对象创建字典
print(dict([('one', 1), ('two', 2)]))
print('*' * 50)

# 3、从一个带key和value的可迭代对象创建字典
d = {'one': 1, 'two': 2}
dt = {}
for k, v in d.items():
    dt[k] = v
print(dt)
print('*' * 50)

# 4、以name=value对创建字典
print(dict(one=1, two=2))

{}
**************************************************
{'one': 1, 'two': 2}
**************************************************
{'one': 1, 'two': 2}
**************************************************
{'one': 1, 'two': 2}

10、set

class set(object)
 |  set() -> new empty set object
 |  set(iterable) -> new set object

# 1、创建空集合
print(set())

# 2、可迭代对象转换为集合
print(set([1, 2, 1, 2]))

set()      # 空集合这样表示，{}表示字典
{1, 2}

11、frozenset

class frozenset(object)
 |  frozenset() -> empty frozenset object
 |  frozenset(iterable) -> frozenset object
 | 
 |  Build an immutable unordered collection of unique elements.
    # 与set的区别是不可变得

# 1、创建空集合
print(frozenset())

# 2、可迭代对象转换为集合
fs = frozenset([1, 2, 1, 2])
print(fs)

# 3、为set和frozenset对象添加元素
s = set((100, ))
s.add(10)
print(s)

fs.add(10)   

frozenset()
frozenset({1, 2})
{10, 100}
Traceback (most recent call last):
  File "1.py", line 14, in <module>
    fs.add(10)   
AttributeError: 'frozenset' object has no attribute 'add'

12、complex

class complex(object)
 |  complex(real[, imag]) -> complex number
 | 
 |  Create a complex number from a real part and an optional imaginary part.
 |  This is equivalent to (real + imag*1j) where imag defaults to 0.

print(complex(10))
print(complex(10, 10))
a = 10 + 0j
print(a)
print(a == 10)

(10+0j)
(10+10j)
(10+0j)
True

13、type

class type(object)
 |  type(object_or_name, bases, dict)
    # 创建一个类
 |  type(object) -> the object's type
    # 查看这个对象的类型
 |  type(name, bases, dict) -> a new type
    # 

# type功能1，判断对象的类型
print(type(int))
print(type(100))


# type功能2，动态创建类
# 第一个参数是字符串
# 第二个参数是父类的元组
# 第三个参数是属性的字典
class Animal():
    pass

Dog = type('Dog', (Animal,), {})
dog = Dog()

print(type(Dog))
print(type(dog))