python基础之一——数据类型和内存管理

156 阅读 0 评论 103 点赞

我是靠谱客的博主高兴烧鹅，这篇文章主要介绍python基础之一——数据类型和内存管理，现在分享给大家，希望可以做个参考。

本博客所有文章仅仅是博主做笔记之用，博客内容并不详细（以后有空会修改完善），思维也有跳跃之处，想详细学习博客内容可参考文章后面的参考链接，祝学习快乐。

本节要点：

数据类型
内存管理
深浅copy

学习Python一定要记住的一点：一切皆对象！

数据类型

整数

和其他语言不同，Python所能表示的整数大小只受限于机器内存，并无固定的字节数。
bool类型

False和0表示假，其他的都为真。
浮点数
注意两点：
1. 浮点数的精度依赖于解释器，不同的IDE下可能不同
2. 比较两个浮点数不能用 a==b，而要用abs（a-b）<=sys.float_info.epsilon来判断。
字符串

字符串常用方法：

 |
capitalize(...)
|
S.capitalize() -> str
|
|
Return a capitalized version of S, i.e. make the first character
|
have upper case and the rest lower case.
|
|
casefold(...)
|
S.casefold() -> str
|
|
Return a version of S suitable for caseless comparisons.
|
|
center(...)
|
S.center(width[, fillchar]) -> str
|
|
Return S centered in a string of length width. Padding is
|
done using the specified fill character (default is a space)
|
|
count(...)
|
S.count(sub[, start[, end]]) -> int
|
|
Return the number of non-overlapping occurrences of substring sub in
|
string S[start:end].
Optional arguments start and end are
|
interpreted as in slice notation.
|
|
encode(...)
|
S.encode(encoding='utf-8', errors='strict') -> bytes
|
|
Encode S using the codec registered for encoding. Default encoding
|
is 'utf-8'. errors may be given to set a different error
|
handling scheme. Default is 'strict' meaning that encoding errors raise
|
a UnicodeEncodeError. Other possible values are 'ignore', 'replace' and
|
'xmlcharrefreplace' as well as any other name registered with
|
codecs.register_error that can handle UnicodeEncodeErrors.
|
|
endswith(...)
|
S.endswith(suffix[, start[, end]]) -> bool
|
|
Return True if S ends with the specified suffix, False otherwise.
|
With optional start, test S beginning at that position.
|
With optional end, stop comparing S at that position.
|
suffix can also be a tuple of strings to try.
|
|
expandtabs(...)
|
S.expandtabs(tabsize=8) -> str
|
|
Return a copy of S where all tab characters are expanded using spaces.
|
If tabsize is not given, a tab size of 8 characters is assumed.
|
|
find(...)
|
S.find(sub[, start[, end]]) -> int
|
|
Return the lowest index in S where substring sub is found,
|
such that sub is contained within S[start:end].
Optional
|
arguments start and end are interpreted as in slice notation.
|
|
Return -1 on failure.
|
|
format(...)
|
S.format(*args, **kwargs) -> str
|
|
Return a formatted version of S, using substitutions from args and kwargs.
|
The substitutions are identified by braces ('{' and '}').
|
|
format_map(...)
|
S.format_map(mapping) -> str
|
|
Return a formatted version of S, using substitutions from mapping.
|
The substitutions are identified by braces ('{' and '}').
|
|
index(...)
|
S.index(sub[, start[, end]]) -> int
|
|
Like S.find() but raise ValueError when the substring is not found.
|
|
isalnum(...)
|
S.isalnum() -> bool
|
|
Return True if all characters in S are alphanumeric
|
and there is at least one character in S, False otherwise.
|
|
isalpha(...)
|
S.isalpha() -> bool
|
|
Return True if all characters in S are alphabetic
|
and there is at least one character in S, False otherwise.
|
|
isdecimal(...)
|
S.isdecimal() -> bool
|
|
Return True if there are only decimal characters in S,
|
False otherwise.
|
|
isdigit(...)
|
S.isdigit() -> bool
|
|
Return True if all characters in S are digits
|
and there is at least one character in S, False otherwise.
|
|
isidentifier(...)
|
S.isidentifier() -> bool
|
|
Return True if S is a valid identifier according
|
to the language definition.
|
|
Use keyword.iskeyword() to test for reserved identifiers
|
such as "def" and "class".
|
|
islower(...)
|
S.islower() -> bool
|
|
Return True if all cased characters in S are lowercase and there is
|
at least one cased character in S, False otherwise.
|
|
isnumeric(...)
|
S.isnumeric() -> bool
|
|
Return True if there are only numeric characters in S,
|
False otherwise.
|
|
isprintable(...)
|
S.isprintable() -> bool
|
|
Return True if all characters in S are considered
|
printable in repr() or S is empty, False otherwise.
|
|
isspace(...)
|
S.isspace() -> bool
|
|
Return True if all characters in S are whitespace
|
and there is at least one character in S, False otherwise.
|
|
istitle(...)
|
S.istitle() -> bool
|
|
Return True if S is a titlecased string and there is at least one
|
character in S, i.e. upper- and titlecase characters may only
|
follow uncased characters and lowercase characters only cased ones.
|
Return False otherwise.
|
|
isupper(...)
|
S.isupper() -> bool
|
|
Return True if all cased characters in S are uppercase and there is
|
at least one cased character in S, False otherwise.
|
|
join(...)
|
S.join(iterable) -> str
|
|
Return a string which is the concatenation of the strings in the
|
iterable.
The separator between elements is S.
|
|
ljust(...)
|
S.ljust(width[, fillchar]) -> str
|
|
Return S left-justified in a Unicode string of length width. Padding is
|
done using the specified fill character (default is a space).
|
|
lower(...)
|
S.lower() -> str
|
|
Return a copy of the string S converted to lowercase.
|
|
lstrip(...)
|
S.lstrip([chars]) -> str
|
|
Return a copy of the string S with leading whitespace removed.
|
If chars is given and not None, remove characters in chars instead.
|
|
partition(...)
|
S.partition(sep) -> (head, sep, tail)
|
|
Search for the separator sep in S, and return the part before it,
|
the separator itself, and the part after it.
If the separator is not
|
found, return S and two empty strings.
|
|
replace(...)
|
S.replace(old, new[, count]) -> str
|
|
Return a copy of S with all occurrences of substring
|
old replaced by new.
If the optional argument count is
|
given, only the first count occurrences are replaced.
|
|
rfind(...)
|
S.rfind(sub[, start[, end]]) -> int
|
|
Return the highest index in S where substring sub is found,
|
such that sub is contained within S[start:end].
Optional
|
arguments start and end are interpreted as in slice notation.
|
|
Return -1 on failure.
|
|
rindex(...)
|
S.rindex(sub[, start[, end]]) -> int
|
|
Like S.rfind() but raise ValueError when the substring is not found.
|
|
rjust(...)
|
S.rjust(width[, fillchar]) -> str
|
|
Return S right-justified in a string of length width. Padding is
|
done using the specified fill character (default is a space).
|
|
rpartition(...)
|
S.rpartition(sep) -> (head, sep, tail)
|
|
Search for the separator sep in S, starting at the end of S, and return
|
the part before it, the separator itself, and the part after it.
If the
|
separator is not found, return two empty strings and S.
|
|
rsplit(...)
|
S.rsplit(sep=None, maxsplit=-1) -> list of strings
|
|
Return a list of the words in S, using sep as the
|
delimiter string, starting at the end of the string and
|
working to the front.
If maxsplit is given, at most maxsplit
|
splits are done. If sep is not specified, any whitespace string
|
is a separator.
|
|
rstrip(...)
|
S.rstrip([chars]) -> str
|
|
Return a copy of the string S with trailing whitespace removed.
|
If chars is given and not None, remove characters in chars instead.
|
|
split(...)
|
S.split(sep=None, maxsplit=-1) -> list of strings
|
|
Return a list of the words in S, using sep as the
|
delimiter string.
If maxsplit is given, at most maxsplit
|
splits are done. If sep is not specified or is None, any
|
whitespace string is a separator and empty strings are
|
removed from the result.
|
|
splitlines(...)
|
S.splitlines([keepends]) -> list of strings
|
|
Return a list of the lines in S, breaking at line boundaries.
|
Line breaks are not included in the resulting list unless keepends
|
is given and true.
|
|
startswith(...)
|
S.startswith(prefix[, start[, end]]) -> bool
|
|
Return True if S starts with the specified prefix, False otherwise.
|
With optional start, test S beginning at that position.
|
With optional end, stop comparing S at that position.
|
prefix can also be a tuple of strings to try.
|
|
strip(...)
|
S.strip([chars]) -> str
|
|
Return a copy of the string S with leading and trailing
|
whitespace removed.
|
If chars is given and not None, remove characters in chars instead.
|
|
swapcase(...)
|
S.swapcase() -> str
|
|
Return a copy of S with uppercase characters converted to lowercase
|
and vice versa.
|
|
title(...)
|
S.title() -> str
|
|
Return a titlecased version of S, i.e. words start with title case
|
characters, all remaining cased characters have lower case.
|
|
translate(...)
|
S.translate(table) -> str
|
|
Return a copy of the string S in which each character has been mapped
|
through the given translation table. The table must implement
|
lookup/indexing via __getitem__, for instance a dictionary or list,
|
mapping Unicode ordinals to Unicode ordinals, strings, or None. If
|
this operation raises LookupError, the character is left untouched.
|
Characters mapped to None are deleted.
|
|
upper(...)
|
S.upper() -> str
|
|
Return a copy of S converted to uppercase.
|
|
zfill(...)
|
S.zfill(width) -> str
|
|
Pad a numeric string S with zeros on the left, to fill a field
|
of the specified width. The string S is never truncated.

这里写图片描述

字符串格式规约
这里写图片描述
语法格式：
[fill][align][sign][#][0][width][.][.precision][type]

参数解析：
fill： any character except ‘}’, 填充字符
align： ”<“left,“ >”right, “^”center 对齐方式， “=”用于在符号与数字之间进行填充（.format（int））
sign： “+” | “-” | ” ” 数字是否带正负标识，“+”表示必须输出符号，“-”表示只输出负数符号，“ ”空格表示为正数输出空格，为负数输出“-”
#：整数前缀为 0b, 0o, 0x
width：最小宽度
precision：浮点型小数位数或字符串的最大长度
type： “b” | “c” | “d” | “e” | “E” | “f” | “g” | “G” | “n” | “o” | “x” | “X” | “%” 类型

字符串格式规约是使用冒号（：）引入的，其后跟随可选的字符——一个填充字符（也可没有）与一个对齐字符（<用于左对齐，>用于右对齐，^用于中间对齐），之后跟随的是可选的最小宽度（整数），若需要指定最大宽度，就在其后使用句点，句点后跟随一个整数。
注意：如果我们指定了一个填充字符，就必须同时指定对齐字符。

>>> s="Simple is better than complex."
>>> "{}".format(s)
#一般格式
'Simple is better than complex.'
>>> "{:40}".format(s)
#最小40个字符
'Simple is better than complex.
'
>>> "{:>40}".format(s)
'
Simple is better than complex.'
>>> "{:^40}".format(s)
'
Simple is better than complex.
'
>>> "{:-^40}".format(s)
'-----Simple is better than complex.-----'
>>> "{:.<40}".format(s)
#指定了一个填充字符，就必须同时指定对齐字符。
'Simple is better than complex...........'
>>> "{:.10}".format(s)
#最长10个字符
'Simple is '
>>> "{:#=40}".format("-34546")
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: '=' alignment not allowed in string format specifier
>>> "{:#=40}".format(34546)
'###################################34546'
>>> "{: }".format(12345)
' 12345'
>>> "{:*^ 15}".format(1234)
'***** 1234*****'
>>> "{:*^-15}".format(1234)
'*****1234******'
>>> "{:*^-15}".format(-1234)
'*****-1234*****'
>>> "{:*^+15}".format(1234)
'*****+1234*****'
>>> "{:*^#15x}".format(1234)
'*****0x4d2*****'
>>> "{:*^#15b}".format(34)
'***0b100010****'

列表

 |
append(...)
|
L.append(object) -> None -- append object to end
|
|
clear(...)
|
L.clear() -> None -- remove all items from L
|
|
copy(...)
|
L.copy() -> list -- a shallow copy of L
|
|
count(...)
|
L.count(value) -> integer -- return number of occurrences of value
|
|
extend(...)
|
L.extend(iterable) -> None -- extend list by appending elements from the iterable
|
|
index(...)
|
L.index(value, [start, [stop]]) -> integer -- return first index of value.
|
Raises ValueError if the value is not present.
|
|
insert(...)
|
L.insert(index, object) -- insert object before index
|
|
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.
|
|
remove(...)
|
L.remove(value) -> None -- remove first occurrence of value.
|
Raises ValueError if the value is not present.
|
|
reverse(...)
|
L.reverse() -- reverse *IN PLACE*
|
|
sort(...)
|
L.sort(key=None, reverse=False) -> None -- stable sort *IN PLACE*

元组

 |
count(...)
|
T.count(value) -> integer -- return number of occurrences of value
|
|
index(...)
|
T.index(value, [start, [stop]]) -> integer -- return first index of value.
|
Raises ValueError if the value is not present.

字典

 |
clear(...)
|
D.clear() -> None.
Remove all items from D.
|
|
copy(...)
|
D.copy() -> a shallow copy of D
|
|
fromkeys(iterable, value=None, /) from builtins.type
|
Returns a new dict with keys from iterable and values equal to value.
|
|
get(...)
|
D.get(k[,d]) -> D[k] if k in D, else d.
d defaults to None.
|
|
items(...)
|
D.items() -> a set-like object providing a view on D's items
|
|
keys(...)
|
D.keys() -> a set-like object providing a view on D's keys
|
|
pop(...)
|
D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
|
If key is not found, d is returned if given, otherwise KeyError is raised
|
|
popitem(...)
|
D.popitem() -> (k, v), remove and return some (key, value) pair as a
|
2-tuple; but raise KeyError if D is empty.
|
|
setdefault(...)
|
D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D
|
|
update(...)
|
D.update([E, ]**F) -> None.
Update D from dict/iterable E and F.
|
If E is present and has a .keys() method, then does:
for k in E: D[k] = E[k]
|
If E is present and lacks a .keys() method, then does:
for k, v in E: D[k] = v
|
In either case, this is followed by: for k in F:
D[k] = F[k]
|
|
values(...)
|
D.values() -> an object providing a view on D's values

bytes和bytearray类型（Python 3新增类型）
set和frozenset
只有可哈希运算的对象才可以添加到集合中。所有内置的固定数据类型（int，str，tuple，float，frozeset）都是可哈希运算的，可以添加到集合中，内置的可变数据类型（list，dict，set）都是不可哈希运算的，因为其哈希值会随着数据项的变化而变化，所以不能添加到集合中。

内存管理

再次重复开头的一句话：一切皆对象

1. Python变量、对象、引用、存储

python语言是一种解释性的编程语言，在运行的过程中，逐句将指令解释成机器码，所以造就了python语言一些特别的地方。

Python有个特别的机制，它会在解释器启动的时候事先分配好一些缓冲区，这些缓冲区部分是固定好取值，例如整数[-5，256]的内存地址是固定的(这里的固定指这一次程序启动之后，这些数字在这个程序中的内存地址就不变了，但是启动新的python程序，两次的内存地址不一样)。
另外，Python在启动的时候还会有一块可重复利用的缓冲区。

#固定缓冲区
>>> a=-5
>>> b=-5
>>> id(-5)
505370256
>>> id(a)
505370256
>>> id(b)
505370256
>>> c=256
>>> d=256
>>> print(id(c),id(d),id(256))
505374432 505374432 505374432
>>> e=257
>>> f=257
>>> print(id(e),id(f),id(257))
54155072 54155104 54155120
#可重复利用缓冲区（不同电脑，不同编译器，有可能不一样）
>>> id(10000)
2660846579440
>>> id(1000010)
2660846579440
>>> id(1000)
2660846579440
>>> id(1233)
2660846579440

对于列表和元组，存储的其实并不是数据项，而是每个元素的引用。

这里写图片描述

如图，对于列表，L是这个列表对象的引用，对象里面存的是每个元素的引用，而不是直接存储数据。

当把一个list变量赋值给另外一个变量时，这两个变量是等价的，它们都是原来对象的一个引用。

>>> a=[1,2,3,[1,2]]
>>> b=a
>>> print(id(a),id(b))
56164304 56164304
>>> b[1]="hello"
>>> a
[1, 'hello', 3, [1, 2]]
>>> b
[1, 'hello', 3, [1, 2]]
>>> b[3].append(9)
>>> a
[1, 'hello', 3, [1, 2, 9]]
>>> b
[1, 'hello', 3, [1, 2, 9]]

但是实际使用中，可能需要的是将里面的内容给复制出来到一个新的地址空间，这里可以使用python的copy模块，copy模块分为两种拷贝，一种是浅拷贝，一种是深拷贝。

二者唯一的区别在于对复合类型对象的处理上，比如列表和类实例。

假设处理一个list对象，浅拷贝调用函数copy.copy()，产生了一块新的内存来存放list中的每个元素引用，也就是说每个元素的跟原来list中元素地址是一样的。而深复制copy.deepcopy()，会开辟一块新的内存来存放复合类型。

>>> a=[1234,"123",[1,2,899]]
>>> b=copy.copy(a)
>>> c=copy.deepcopy(a)
>>> print(id(a),id(b),id(c))
52773272 52624680 52625320
#这是三个不同的对象
>>> print(id(a[0]),id(b[0]),id(c[0]))
52320176 52320176 52320176
#对于简单数据类型的处理是一样的
>>> print(id(a[2]),id(b[2]),id(c[2]))
52774512 52774512 52625160
# 注意啦，区别就在这