exit()format()getattr()golbals()hasattr()hash()2018-10-8
经过前几天的测试，发现以下几个问题：
1 效率低下，一天cost 两小时左右，大部分时间在I|O，真正记忆时间很少
2 这样学英语，单词不方便复习，经过查立资料发现一个比较好的学习python英语词汇的方法——‘扇贝单词’，搜索python。
3 这样学python，基本上还是靠自己测试及网上查询文档
做出以下调整：
1 、内置源代码手敲一遍，不懂的单词直接翻译
2 ､ 根据指示，如果有help()，把help源码也贴出来
3 、英语单词上下文意思写在‘menu’里
4 、源码的百度翻译也贴出来，虽然意思经常不准确，但是可以帮助对比学习一些单词
4 、陌生函数的理解，包括：用途-解决什么问题，麻烦|带来什么麻烦 ，语法，运用场景，代码测试等等
#builtins source code:
def exit(*args , **kwargs):#real signature unknown
pass
def format(*args , **kwargs):#real signature unknow
'''
Return value.__format__(format_spec【格式规范】)
format_spec defaults to the empty sting.
See the Format Specification【规范】 Mini-Language【迷你语言】 section【部分】 fo help('FORMATTING') for details.
'''
pass
def getattr(object , name , default=None):#known special case of getattr
'''
getattr(object , name[, default]) -> value
Get a named attribute from an object; getattr(x , 'y') is equivalent to x.y.
When a default argument is given,it is returned when the attribute doens't exist;wihtout it ,an exceptions is raised in that case.
'''
pass
def globals(*args , **kwargs):#real signature unknow
'''
Return the dictionary containing the current scope's【范围的】 global variables.
NOTE:Updates to this dictionary *will* affect the name lookups【查找程序】 in the current global scope and vice-versa【反之亦然】.
'''
pass
def hasattr(*args , **kwargs):#real signature unknow
'''
Return whether the object has an attribute with the given name.
This is done by calling getattr(obj,name) and catching AttributeError
'''
pass
def hash(*args , **kwargs):#real signature unknow
'''
Return the hash value for the given object
Two objects that compare equal must also have the same hash value,but the reverse【倒序】 is not necessarily（必然地，必要地，必须的） true.
'''
pass
help_FORMATTING = '''
Format String Syntax
********************
The "str.format()" method and the "Formatter" class share the same
syntax for format strings (although in the case of "Formatter",
subclasses can define their own format string syntax). The syntax is
related to that of formatted string literals, but there are
differences.
Format strings contain “replacement fields” surrounded by curly braces
"{}". Anything that is not contained in braces is considered literal
text, which is copied unchanged to the output. If you need to include
a brace character in the literal text, it can be escaped by doubling:
"{{" and "}}".
The grammar for a replacement field is as follows:
replacement_field ::= "{" [field_name] ["!" conversion] [":" format_spec] "}"
field_name ::= arg_name ("." attribute_name | "[" element_index "]")*
arg_name ::= [identifier | digit+]
attribute_name ::= identifier
element_index ::= digit+ | index_string
index_string ::= <any source character except "]"> +
conversion ::= "r" | "s" | "a"
format_spec ::= <described in the next section>
In less formal terms, the replacement field can start with a
*field_name* that specifies the object whose value is to be formatted
and inserted into the output instead of the replacement field. The
*field_name* is optionally followed by a *conversion* field, which is
preceded by an exclamation point "'!'", and a *format_spec*, which is
preceded by a colon "':'". These specify a non-default format for the
replacement value.
See also the Format Specification Mini-Language section.
The *field_name* itself begins with an *arg_name* that is either a
number or a keyword. If it’s a number, it refers to a positional
argument, and if it’s a keyword, it refers to a named keyword
argument. If the numerical arg_names in a format string are 0, 1, 2,
… in sequence, they can all be omitted (not just some) and the numbers
0, 1, 2, … will be automatically inserted in that order. Because
*arg_name* is not quote-delimited, it is not possible to specify
arbitrary dictionary keys (e.g., the strings "'10'" or "':-]'") within
a format string. The *arg_name* can be followed by any number of index
or attribute expressions. An expression of the form "'.name'" selects
the named attribute using "getattr()", while an expression of the form
"'[index]'" does an index lookup using "__getitem__()".
Changed in version 3.1: The positional argument specifiers can be
omitted, so "'{} {}'" is equivalent to "'{0} {1}'".
Some simple format string examples:
"First, thou shalt count to {0}" # References first positional argument
"Bring me a {}" # Implicitly references the first positional argument
"From {} to {}" # Same as "From {0} to {1}"
"My quest is {name}" # References keyword argument 'name'
"Weight in tons {0.weight}" # 'weight' attribute of first positional arg
"Units destroyed: {players[0]}" # First element of keyword argument 'players'.
The *conversion* field causes a type coercion before formatting.
Normally, the job of formatting a value is done by the "__format__()"
method of the value itself. However, in some cases it is desirable to
force a type to be formatted as a string, overriding its own
definition of formatting. By converting the value to a string before
calling "__format__()", the normal formatting logic is bypassed.
Three conversion flags are currently supported: "'!s'" which calls
"str()" on the value, "'!r'" which calls "repr()" and "'!a'" which
calls "ascii()".
Some examples:
"Harold's a clever {0!s}" # Calls str() on the argument first
"Bring out the holy {name!r}" # Calls repr() on the argument first
"More {!a}" # Calls ascii() on the argument first
The *format_spec* field contains a specification of how the value
should be presented, including such details as field width, alignment,
padding, decimal precision and so on. Each value type can define its
own “formatting mini-language” or interpretation of the *format_spec*.
Most built-in types support a common formatting mini-language, which
is described in the next section.
A *format_spec* field can also include nested replacement fields
within it. These nested replacement fields may contain a field name,
conversion flag and format specification, but deeper nesting is not
allowed. The replacement fields within the format_spec are
substituted before the *format_spec* string is interpreted. This
allows the formatting of a value to be dynamically specified.
See the Format examples section for some examples.
Format Specification Mini-Language
==================================
“Format specifications” are used within replacement fields contained
within a format string to define how individual values are presented
(see Format String Syntax and Formatted string literals). They can
also be passed directly to the built-in "format()" function. Each
formattable type may define how the format specification is to be
interpreted.
Most built-in types implement the following options for format
specifications, although some of the formatting options are only
supported by the numeric types.
A general convention is that an empty format string ("""") produces
the same result as if you had called "str()" on the value. A non-empty
format string typically modifies the result.
The general form of a *standard format specifier* is:
format_spec ::= [[fill]align][sign][#][0][width][grouping_option][.precision][type]
fill ::= <any character>
align ::= "<" | ">" | "=" | "^"
sign ::= "+" | "-" | " "
width ::= digit+
grouping_option ::= "_" | ","
precision ::= digit+
type ::= "b" | "c" | "d" | "e" | "E" | "f" | "F" | "g" | "G" | "n" | "o" | "s" | "x" | "X" | "%"
If a valid *align* value is specified, it can be preceded by a *fill*
character that can be any character and defaults to a space if
omitted. It is not possible to use a literal curly brace (“"{"” or
“"}"”) as the *fill* character in a formatted string literal or when
using the "str.format()" method. However, it is possible to insert a
curly brace with a nested replacement field. This limitation doesn’t
affect the "format()" function.
The meaning of the various alignment options is as follows:
+-----------+------------------------------------------------------------+
| Option | Meaning |
+===========+============================================================+
| "'<'" | Forces the field to be left-aligned within the available |
| | space (this is the default for most objects). |
+-----------+------------------------------------------------------------+
| "'>'" | Forces the field to be right-aligned within the available |
| | space (this is the default for numbers). |
+-----------+------------------------------------------------------------+
| "'='" | Forces the padding to be placed after the sign (if any) |
| | but before the digits. This is used for printing fields |
| | in the form ‘+000000120’. This alignment option is only |
| | valid for numeric types. It becomes the default when ‘0’ |
| | immediately precedes the field width. |
+-----------+------------------------------------------------------------+
| "'='" | Forces the padding to be placed after the sign (if any) |
| | but before the digits. This is used for printing fields |
| | in the form ‘+000000120’. This alignment option is only |
| | valid for numeric types. It becomes the default when ‘0’ |
| | immediately precedes the field width. |
+-----------+------------------------------------------------------------+
| "'^'" | Forces the field to be centered within the available |
| | space. |
+-----------+------------------------------------------------------------+
Note that unless a minimum field width is defined, the field width
will always be the same size as the data to fill it, so that the
alignment option has no meaning in this case.
The *sign* option is only valid for number types, and can be one of
the following:
+-----------+------------------------------------------------------------+
| Option | Meaning |
+===========+============================================================+
| "'+'" | indicates that a sign should be used for both positive as |
| | well as negative numbers. |
+-----------+------------------------------------------------------------+
| "'-'" | indicates that a sign should be used only for negative |
| | numbers (this is the default behavior). |
+-----------+------------------------------------------------------------+
| space | indicates that a leading space should be used on positive |
| | numbers, and a minus sign on negative numbers. |
+-----------+------------------------------------------------------------+
The "'#'" option causes the “alternate form” to be used for the
conversion. The alternate form is defined differently for different
types. This option is only valid for integer, float, complex and
Decimal types. For integers, when binary, octal, or hexadecimal output
is used, this option adds the prefix respective "'0b'", "'0o'", or
"'0x'" to the output value. For floats, complex and Decimal the
alternate form causes the result of the conversion to always contain a
decimal-point character, even if no digits follow it. Normally, a
decimal-point character appears in the result of these conversions
only if a digit follows it. In addition, for "'g'" and "'G'"
conversions, trailing zeros are not removed from the result.
The "','" option signals the use of a comma for a thousands separator.
For a locale aware separator, use the "'n'" integer presentation type
instead.
Changed in version 3.1: Added the "','" option (see also **PEP 378**).
The "'_'" option signals the use of an underscore for a thousands
separator for floating point presentation types and for integer
presentation type "'d'". For integer presentation types "'b'", "'o'",
"'x'", and "'X'", underscores will be inserted every 4 digits. For
other presentation types, specifying this option is an error.
Changed in version 3.6: Added the "'_'" option (see also **PEP 515**).
*width* is a decimal integer defining the minimum field width. If not
specified, then the field width will be determined by the content.
When no explicit alignment is given, preceding the *width* field by a
zero ("'0'") character enables sign-aware zero-padding for numeric
types. This is equivalent to a *fill* character of "'0'" with an
*alignment* type of "'='".
The *precision* is a decimal number indicating how many digits should
be displayed after the decimal point for a floating point value
formatted with "'f'" and "'F'", or before and after the decimal point
for a floating point value formatted with "'g'" or "'G'". For non-
number types the field indicates the maximum field size - in other
words, how many characters will be used from the field content. The
*precision* is not allowed for integer values.
Finally, the *type* determines how the data should be presented.
The available string presentation types are:
+-----------+------------------------------------------------------------+
| Type | Meaning |
+===========+============================================================+
| "'s'" | String format. This is the default type for strings and |
| | may be omitted. |
+-----------+------------------------------------------------------------+
| None | The same as "'s'". |
+-----------+------------------------------------------------------------+
The available integer presentation types are:
+-----------+------------------------------------------------------------+
| Type | Meaning |
+===========+============================================================+
| "'b'" | Binary format. Outputs the number in base 2. |
+-----------+------------------------------------------------------------+
| "'c'" | Character. Converts the integer to the corresponding |
| | unicode character before printing. |
+-----------+------------------------------------------------------------+
| "'d'" | Decimal Integer. Outputs the number in base 10. |
+-----------+------------------------------------------------------------+
| "'o'" | Octal format. Outputs the number in base 8. |
+-----------+------------------------------------------------------------+
| "'x'" | Hex format. Outputs the number in base 16, using lower- |
| | case letters for the digits above 9. |
+-----------+------------------------------------------------------------+
| "'X'" | Hex format. Outputs the number in base 16, using upper- |
| | case letters for the digits above 9. |
+-----------+------------------------------------------------------------+
| "'n'" | Number. This is the same as "'d'", except that it uses the |
| | current locale setting to insert the appropriate number |
| | separator characters. |
+-----------+------------------------------------------------------------+
| None | The same as "'d'". |
+-----------+------------------------------------------------------------+
In addition to the above presentation types, integers can be formatted
with the floating point presentation types listed below (except "'n'"
and "None"). When doing so, "float()" is used to convert the integer
to a floating point number before formatting.
The available presentation types for floating point and decimal values
are:
+-----------+------------------------------------------------------------+
| Type | Meaning |
+===========+============================================================+
| "'e'" | Exponent notation. Prints the number in scientific |
| | notation using the letter ‘e’ to indicate the exponent. |
| | The default precision is "6". |
+-----------+------------------------------------------------------------+
| "'E'" | Exponent notation. Same as "'e'" except it uses an upper |
| | case ‘E’ as the separator character. |
+-----------+------------------------------------------------------------+
| "'f'" | Fixed point. Displays the number as a fixed-point number. |
| | The default precision is "6". |
+-----------+------------------------------------------------------------+
| "'F'" | Fixed point. Same as "'f'", but converts "nan" to "NAN" |
| | and "inf" to "INF". |
+-----------+------------------------------------------------------------+
| "'g'" | General format. For a given precision "p >= 1", this |
| | rounds the number to "p" significant digits and then |
| | formats the result in either fixed-point format or in |
| | scientific notation, depending on its magnitude. The |
| | precise rules are as follows: suppose that the result |
| | formatted with presentation type "'e'" and precision "p-1" |
| | would have exponent "exp". Then if "-4 <= exp < p", the |
| | number is formatted with presentation type "'f'" and |
| | precision "p-1-exp". Otherwise, the number is formatted |
| | with presentation type "'e'" and precision "p-1". In both |
| | cases insignificant trailing zeros are removed from the |
| | significand, and the decimal point is also removed if |
| | there are no remaining digits following it. Positive and |
| | negative infinity, positive and negative zero, and nans, |
| | are formatted as "inf", "-inf", "0", "-0" and "nan" |
| | respectively, regardless of the precision. A precision of |
| | "0" is treated as equivalent to a precision of "1". The |
| | default precision is "6". |
+-----------+------------------------------------------------------------+
| "'G'" | General format. Same as "'g'" except switches to "'E'" if |
| | the number gets too large. The representations of infinity |
| | and NaN are uppercased, too. |
+-----------+------------------------------------------------------------+
| "'n'" | Number. This is the same as "'g'", except that it uses the |
| | current locale setting to insert the appropriate number |
| | separator characters. |
+-----------+------------------------------------------------------------+
| "'%'" | Percentage. Multiplies the number by 100 and displays in |
| | fixed ("'f'") format, followed by a percent sign. |
+-----------+------------------------------------------------------------+
| None | Similar to "'g'", except that fixed-point notation, when |
| | used, has at least one digit past the decimal point. The |
| | default precision is as high as needed to represent the |
| | particular value. The overall effect is to match the |
| | output of "str()" as altered by the other format |
| | modifiers. |
+-----------+------------------------------------------------------------+
Format examples
===============
This section contains examples of the "str.format()" syntax and
comparison with the old "%"-formatting.
In most of the cases the syntax is similar to the old "%"-formatting,
with the addition of the "{}" and with ":" used instead of "%". For
example, "'%03.2f'" can be translated to "'{:03.2f}'".
The new format syntax also supports new and different options, shown
in the follow examples.
Accessing arguments by position:
>>> '{0}, {1}, {2}'.format('a', 'b', 'c')
'a, b, c'
>>> '{}, {}, {}'.format('a', 'b', 'c') # 3.1+ only
'a, b, c'
>>> '{2}, {1}, {0}'.format('a', 'b', 'c')
'c, b, a'
>>> '{2}, {1}, {0}'.format(*'abc') # unpacking argument sequence
'c, b, a'
>>> '{0}{1}{0}'.format('abra', 'cad') # arguments' indices can be repeated
'abracadabra'
Accessing arguments by name:
>>> 'Coordinates: {latitude}, {longitude}'.format(latitude='37.24N', longitude='-115.81W')
'Coordinates: 37.24N, -115.81W'
>>> coord = {'latitude': '37.24N', 'longitude': '-115.81W'}
>>> 'Coordinates: {latitude}, {longitude}'.format(**coord)
'Coordinates: 37.24N, -115.81W'
Accessing arguments’ attributes:
>>> c = 3-5j
>>> ('The complex number {0} is formed from the real part {0.real} '
... 'and the imaginary part {0.imag}.').format(c)
'The complex number (3-5j) is formed from the real part 3.0 and the imaginary part -5.0.'
>>> class Point:
... def __init__(self, x, y):
... self.x, self.y = x, y
... def __str__(self):
... return 'Point({self.x}, {self.y})'.format(self=self)
...
>>> str(Point(4, 2))
'Point(4, 2)'
Accessing arguments’ items:
>>> coord = (3, 5)
>>> 'X: {0[0]}; Y: {0[1]}'.format(coord)
'X: 3; Y: 5'
Replacing "%s" and "%r":
>>> "repr() shows quotes: {!r}; str() doesn't: {!s}".format('test1', 'test2')
"repr() shows quotes: 'test1'; str() doesn't: test2"
Aligning the text and specifying a width:
>>> '{:<30}'.format('left aligned')
'left aligned '
>>> '{:>30}'.format('right aligned')
' right aligned'
>>> '{:^30}'.format('centered')
' centered '
>>> '{:*^30}'.format('centered') # use '*' as a fill char
'***********centered***********'
Replacing "%+f", "%-f", and "% f" and specifying a sign:
>>> '{:+f}; {:+f}'.format(3.14, -3.14) # show it always
'+3.140000; -3.140000'
>>> '{: f}; {: f}'.format(3.14, -3.14) # show a space for positive numbers
' 3.140000; -3.140000'
>>> '{:-f}; {:-f}'.format(3.14, -3.14) # show only the minus -- same as '{:f}; {:f}'
'3.140000; -3.140000'
Replacing "%x" and "%o" and converting the value to different bases:
>>> # format also supports binary numbers
>>> "int: {0:d}; hex: {0:x}; oct: {0:o}; bin: {0:b}".format(42)
'int: 42; hex: 2a; oct: 52; bin: 101010'
>>> # with 0x, 0o, or 0b as prefix:
>>> "int: {0:d}; hex: {0:#x}; oct: {0:#o}; bin: {0:#b}".format(42)
'int: 42; hex: 0x2a; oct: 0o52; bin: 0b101010'
Using the comma as a thousands separator:
>>> '{:,}'.format(1234567890)
'1,234,567,890'
Expressing a percentage:
>>> points = 19
>>> total = 22
>>> 'Correct answers: {:.2%}'.format(points/total)
'Correct answers: 86.36%'
Using type-specific formatting:
>>> import datetime
>>> d = datetime.datetime(2010, 7, 4, 12, 15, 58)
>>> '{:%Y-%m-%d %H:%M:%S}'.format(d)
'2010-07-04 12:15:58'
Nesting arguments and more complex examples:
>>> for align, text in zip('<^>', ['left', 'center', 'right']):
... '{0:{fill}{align}16}'.format(text, fill=align, align=align)
...
'left<<<<<<<<<<<<'
'^^^^^center^^^^^'
'>>>>>>>>>>>right'
>>>
>>> octets = [192, 168, 0, 1]
>>> '{:02X}{:02X}{:02X}{:02X}'.format(*octets)
'C0A80001'
>>> int(_, 16)
3232235521
>>>
>>> width = 5
>>> for num in range(5,12): #doctest: +NORMALIZE_WHITESPACE
... for base in 'dXob':
... print('{0:{width}{base}}'.format(num, base=base, width=width), end=' ')
... print()
...
5 5 5 101
6 6 6 110
7 7 7 111
8 8 10 1000
9 9 11 1001
10 A 12 1010
11 B 13 1011
'''
BaiduTranslate = '''
def exit(*args, **kwargs): # real signature unknown
DEF出口（*ARGs，**KWARGS）：γ真实签名未知
pass
通过
def format(*args, **kwargs): # real signature unknown
DEF格式（*ARGs，**KARGGS）：γ真实签名未知
"""
“”
Return value.__format__(format_spec)
返回值。
format_spec defaults to the empty string.
FuffATS.SPEC默认值为空字符串。
See the Format Specification Mini-Language section of help('FORMATTING') for
请参阅格式规范“帮助”（“格式化”）的迷你语言部分
details.
细节。
"""
“”
pass
通过
def getattr(object, name, default=None): # known special case of getattr
DEFGATATR（对象，名称，缺省＝无）：已知的GATATOR特例
"""
“”
getattr(object, name[, default]) -> value
GATTARC（对象，名称[默认]）->值
Get a named attribute from an object; getattr(x, 'y') is equivalent to x.y.
从一个对象中获取一个命名属性；GETAutr（x，y）等价于x.y。
When a default argument is given, it is returned when the attribute doesn't
当给定默认参数时，当属性不返回时，则返回该参数。
exist; without it, an exception is raised in that case.
如果没有它，在这种情况下会出现例外。
"""
“”
pass
通过
def globals(*args, **kwargs): # real signature unknown
DEF全局（*ARGs，**KARGGS）：未知实签名
"""
“”
Return the dictionary containing the current scope's global variables.
返回包含当前作用域全局变量的字典。
NOTE: Updates to this dictionary *will* affect name lookups in the current
注意：此词典的更新将影响当前的名称查找
global scope and vice-versa.
全局范围，反之亦然。
"""
“”
pass
通过
def hasattr(*args, **kwargs): # real signature unknown
DEF HASTART（*ARGS，**KWARGS）：未知实签名
"""
“”
Return whether the object has an attribute with the given name.
返回对象是否具有给定名称的属性。
This is done by calling getattr(obj, name) and catching AttributeError.
这是通过调用GETAutr（Objo，name）和捕获AttError错误来完成的。
"""
“”
pass
通过
def hash(*args, **kwargs): # real signature unknown
DEF哈希（*ARGs，**KWARGS）：未知实签名
"""
“”
Return the hash value for the given object.
返回给定对象的哈希值。
Two objects that compare equal must also have the same hash value, but the
比较相等的两个对象也必须具有相同的哈希值，但是
reverse is not necessarily true.
反向并不一定是真的。
"""
“”
pass
通过
重点词汇
args
anti-radar guidance sensor 防雷达跟踪传感器
signature unknown签名不祥
Return value返回值
defaults违约; 默认; 弃权( default的名词复数 ); 食言; 弃权( default的第三人称单数 ); 不到庭; 不履行义务
empty string空行
Format Specification格式说明
special case特例，特殊表壳
equivalent to等于，折合
an exception又作别论
in that case如果是那样的话
'''
menu = '''
1 format_spec ：格式规范
2 Specification：规范
3 Mini-Language：迷你语言
4 scope ：范围
5 lookups ：查找程序
6 vice-versa ：反之亦然
7 reverse ：反转，颠倒，倒序
8 necessarily ：必要地
'''
函数1､exit()：可以没参数，也可以有参数。exit('good bye !') --->退出并打印good bye !
>>> exit(1+1)
sh-3.2# python3
Python 3.7.0b4 (v3.7.0b4:eb96c37699, May 2 2018, 01:03:45)
[GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> exit('1+1')
1+1
sh-3.2# python3
Python 3.7.0b4 (v3.7.0b4:eb96c37699, May 2 2018, 01:03:45)
[GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> exit('Bye !')
Bye !
sh-3.2#
函数2､format(),这个函数专门用于字符串的格式化，平时用'%s'占位比较多，当str里占位符'%s'太多时.format能提高代码的易读性。
提出以下需求：
1､为了系统地学习python,欲将str类型的属性全部整理成固定格式，然后存放到印象笔记里，以便离线随时复习。
方法是dir(str)，得到一个列表[]。元互的名字长度不五，一共大概78.第1个与第78个长度也不一致。
为了整齐美观，现在需要格式化
2､银行贷款年利率4.35%怎么表示？
3､怎么在数字间加逗号，千，百万，十亿一目了然。1,000,000,000
4､还有其他的，菜鸟教程关于.format讲得非常细致，详见：http://www.runoob.com/python/att-string-format.html
a = dir(str)
def formart_str(list_sytle , len_order_num_max , name_style ,len_total_max):
b = []
for i in list_sytle:
ii = i.strip()
b.append(ii)
for index, values in enumerate(b):
if len(str(index + 1)) < len_order_num_max:
num = '0' * (len_order_num_max - len(str(index + 1))) + str(index + 1)
else:
num = str(index + 1)
num_str = '第【%s个】%s：' % (num,name_style)
name_str = values + '-' * (len_total_max - len(values)) + ' :'
print(num_str, name_str)
# print(cyan(values))
formart_str(a , 2 , '属性' , 20)
run_result = '''
第【01个】属性： __add__------------- :
第【02个】属性： __class__----------- :
第【08个】属性： __format__---------- :
第【09个】属性： __ge__-------------- :
第【10个】属性： __getattribute__---- :
第【78个】属性： zfill--------------- :
'''
用上.format也许更简单：
>>> a = dir(str)
>>> for index,value in enumerate(a):
... print("第{}个属性{}".format(index+1 , value))
...
第1个属性__add__
第10个属性__getattribute__
第33个属性__subclasshook__
第78个属性zfill
>>> for index,value in enumerate(a):
... print("第{:0>2d}个属性{:-<25s}".format(index+1 , value))
#：帽号是语法，不加帽号报错
#0>:用'0'左填充，2d:加上index一共两位，数字类型。
#-<:用‘-’右填充，25s:加上value一共25位，字符串类型，如果字型填错，比如填d，因为value的值是str,所以填d就会报错
#！！为了方便，干脆不要写'd'|'s'，也是可以执行的。在左边占位还是右边可以这样记：0>2说明0比较大，大的排第一（05,左边）。-<25说明‘-’比较小，小的排后面（name---，-在右边）
...
第01个属性__add__------------------
第10个属性__getattribute__---------
第33个属性__subclasshook__---------
第78个属性zfill--------------------#很整齐
>>> '{:,}'.format(12345678910)
'12,345,678,910'
>>> '{:.2%}'.format(0.0435)
'4.35%'
>>> '{:.5%}'.format(0.0435)
'4.35000%'
>>> '{:0.2%}'.format(0.0435)
'4.35%'
>>> '{:4.2%}'.format(0.0435)#小数点前面
'4.35%'
>>> '{:100.2%}'.format(0.0435)
' 4.35%'
>>> '{:10.2%}'.format(0.0435)
' 4.35%'
>>>
#小数点前面是什么意思？左边的位数还是？
>>> a = '{:100.2%}'.format(0.0435)
>>> len(a)
100
>>> len('{:10.2%}'.format(0.0435))
10
>>> len('{:.2%}'.format(0.0435))
5
>>> len('{:0.2%}'.format(0.0435))
5
>>> len('{:4.2%}'.format(0.0435))
5
>>> len('00000{:4.2%}'.format(0.0435))
10
>>>
#可以看到，小数点左边的数字可以不填，填的话就代表整个{}里的字符位数
#如果填了：填的数字小于{}里所有字符的位数默认为与不填一样的效果，实际多少位就多少位，不会删减
# 大于{}里的长度，就填充空格' '到指定位数
函数3 globals（），查看当前范围所有的全局变量名。
>>> exit()
sh-3.2# python3
Python 3.7.0b4 (v3.7.0b4:eb96c37699, May 2 2018, 01:03:45)
[GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> globals()
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>}
>>> local()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'local' is not defined
>>> locals()
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>}
>>> a = 'fuck'
>>> b= 'shit'
>>> c= '我艹'
>>> def function_test():
... varible_function= '函数里的fuck'
... name = '函数测试'
...
>>> globals()
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, 'a': 'fuck', 'b': 'shit', 'c': '我艹', 'function_test': <function function_test at 0x1020ab1e0>}
>>> locals()#与globals()结果一致
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, 'a': 'fuck', 'b': 'shit', 'c': '我艹', 'function_test': <function function_test at 0x1020ab1e0>}
>>>
>>> def function_test():
... varible_function= '函数里的fuck'
... name = '函数测试'
... print('把locals()放在函数里的结果：{}'.format(locals()))
...
>>> function_test()
把locals()放在函数里的结果：{'varible_function': '函数里的fuck', 'name': '函数测试'}#函数里的变量名和值，如果值是一个复杂的运算表达式会怎么样？
#会计算出结果，打印结果
>>> d = 1+2+3+4+1000000000000000
>>> e = [(i+1)**3 for i in range(10)]
>>> globals()
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, 'a': 'fuck', 'b': 'shit', 'c': '我艹', 'function_test': <function function_test at 0x1021cc488>, 'd': 1000000000000010, 'e': [1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]}
>>>
函数4 hasattr()，在解悉命令时经常用到，if hasattr(): getattr()()。判断一个类|对象是否有函数方法|静态属性
有的话并且是函数的话（函数属性，方法）就可以getattr(obj,'xxx')()执行
没有的话就可提醒用户格式错误
>>> hasattr(str,'__dict__')
True
>>> hasattr(str,'hello')
False
>>> hasattr(str,'__init__')
True
>>>
>>> class Test:
... Thisone = '看看hasattr对类的静态属性|数据属性的执行结果'
... def get(self):
... pass
... def love(self):
... pass
...
>>> t = Test()
>>> hasattr(Test,'Thisone')
True
>>> hasattr(t,'Thisone'
... )
True
>>> hasattr(Test,'get')
True
>>> hasattr(Test,'getd')
False
>>> hasattr(Test,'love')
True
>>> hasattr(t,'get'
... )
True
>>> hasattr(t,'love')
True
>>> hasattr(t,1)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: hasattr(): attribute name must be string
>>> hasattr(t,'1')
False
>>>
函数5 hash( )，没搞懂这个函数的作用干嘛的，与hashlib模块的md5不一样。
>>> import hashlib
>>> md5 = hashlib.md5()
>>> md5.update('hello')
>>> md5.update('hello'.encode())
>>> md5.hexdigest()
'5d41402abc4b2a76b9719d911017c592'
>>> hashlib.md5(b'hello').hexdigest()
'5d41402abc4b2a76b9719d911017c592'
>>> hash('hello')#可以hash()字符串
-7074408507349095176
>>> hash(111)#可以hash()数字，小数点后面加0是一样的
111
>>> hash(111.00)
111
>>> hash([1,2,3])#不能hash()列表
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'
>>> hash((1,2,3))#可以hash()元祖
2528502973977326415
>>> hash({1:1,2:2})#不能hash()字典
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'dict'
>>> hash(None)#hash()0,None,False,‘’（空字符串）都是0,True为1
268591563
>>> hash(0)
0
>>> hash(False)
0
>>> hash(True)
1
>>> hash('')
0
>>>
