提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加
例如：第一章 Python 机器学习入门之pandas的使用
提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档
文章目录- 系列文章目录
- 1.访问[(1, 10), (2, 20), (3, 30)]列表中元组的每个元素
- 2.打印9 * 9乘法表
- 3.运算符的使用：
- str字符串中的方法
- 4、格式化输出：
1.访问[(1, 10), (2, 20), (3, 30)]列表中元组的每个元素
for i, j in [(1, 10), (2, 20), (3, 30)]:
print(i, j)
2.打印9 * 9乘法表
# 第一种
for i in range(1, 10):
j = 1
for j in range(1, i + 1):
print("{} * {} = {:^2}".format(i, j, i * j), end=" ")
print()
# 第二种
i = 1
while i <= 9:
j = 1
while j <= i:
print("{} * {} = {:^2}".format(i, j, i * j), end=" ")
j += 1
print()
i += 1
3.运算符的使用：
算术运算符：所有的英文，以及使用样例
| 符号 | 英文 |
|---|---|
| + | add |
| - | sub |
| * | mul |
| / | div |
| % | mod |
| // | floordiv |
| ** | pow |
print(1 + 1) print(1 - 1)
比较运算符：所有的英文，以及使用样例
| 符号 | 英文 | 缩写 |
|---|---|---|
| == | equal | eq |
| != | not equal | ne |
| > | greater than | gt |
| >= | greater than equal | ge |
| < | less than | lt |
| <= | less than equal | le |
位运算符：&， |， ~， 使用的样例，以及二进制操作的过程
位运算符：操作的是二进制
&：按位与
|：按位或
~：按位取反
^: 按位异或
<<:左移
>>:右移
10 & 10 => 10
10 | 10 => 10
~10 => -11
10 ^ 10 => 0
1010
1010
按位去与: 10 & 10
1 & 1 = 1, 1 & 0 = 0, 0 & 0 = 0
1010 => 10
1010
1010
按位去或： 10 | 10
1 | 1 = 1， 1 | 0 = 1, 0 | 0 = 0
#1 | 0 或者 1 = 1
1010 =》 10
~10 = 》 -11
01010
按位取反： ~10， 对符号位也要取反
10101 =》 补码 -> 反码 -> 原码
10101 =》反码= 补码减一
10100 =》原码= 反码取反(除符号位之外的)
11011 =》原码-> -11
正数，原码，补码，反码 一致
负数：原码，补码，反码 不一致
反码： 是对原码的取反
补码： 反码 + 1
符号位：二进制最高位是我们的符号位。
正数符号位为0
负数符号位为1
<<: 左移
10 << 2
00001010 => 00101000 => 40
>>: 右移
10 >> 2 = >
4.if的三种形式，举样例说明
num = int(input("请输入一个数字"))
print("==========")
if num == 1:
print("1")
print("==========")
if num == 1:
print("1")
else:
print("2")
print("==========")
if num == 1:
print("1")
elif num == 2:
print("2")
else:
print("3")
str字符串中的方法
capitalize(self, /)
| Return a capitalized version of the string.
| # 返回字符串的大写版本。
"""
str_var = "one"
print(str_var.capitalize()) # One
"""
| More specifically, make the first character have upper case and the rest lower
| case.
# 更具体地说，使第一个字符具有大写，其余字符具有小写。
casefold(self, /)
| Return a version of the string suitable for caseless comparisons.
| # 返回适合无大小写比较的字符串版本。(将字符串全部成小写)
"""
str_var1 = "one"
str_var2 = "ONE"
print(str_var1.casefold()) # one
print(str_var2.casefold()) # one
"""
center(self, width, fillchar=' ', /)
| Return a centered string of length width.
| # 返回一个长宽居中的字符串。(如果为奇数，左边会比右边少一个字符)
"""str_var1 = "one"
print(str_var1.center(10, "*"))
"""
| 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
# 返回子字符串sub在中不重叠的出现次数
"""
str_var1 = "abcabcabc"
print(str_var1.count('abc'))
print(str_var1.count('a'))
print(str_var1.count('a', 3, 6))
"""
| string S[start:end]. Optional arguments start and end are
# 字符串S[开始：结束]。可选参数start和end是
| interpreted as in slice notation.
| # 解释为切片表示法。
encode(self, /, encoding='utf-8', errors='strict')
| Encode the string using the codec registered for encoding.
| # 使用注册用于编码的编解码器对字符串进行编码。
| encoding
| The encoding in which to encode the string.
"""
str_var2 = "中文"
str_var3 = str_var2.encode()
print(str_var3) # b'xe4xb8xadxe6x96x87'
"""
# 对字符串进行编码的编码。
| errors
| The error handling scheme to use for encoding errors.
# 用于编码错误的错误处理方案。
| The default is 'strict' meaning that encoding errors raise a
# 默认值为“strict”，表示编码错误会引发
| UnicodeEncodeError. Other possible values are 'ignore', 'replace' and
# UnicodeEncodeError。其他可能的值包括“忽略”、“替换”和
| 'xmlcharrefreplace' as well as any other name registered with
| codecs.register_error that can handle UnicodeEncodeErrors.
| # “xmlcharrefreplace”以及注册于编解码器。registeru错误，可处理UnicodeEncodeErrors。
endswith(...)
| S.endswith(suffix[, start[, end]]) -> bool
| # 判断是否以指定后缀结尾
| Return True if S ends with the specified suffix, False otherwise.
# 如果S以指定后缀结尾，则返回True，否则返回False。
"""
str_var1 = "abcabcabc"
print(str_var1.endswith('abc'))
print(str_var1.endswith('a'))
print(str_var1.endswith('a', 6, 7))
"""
| With optional start, test S beginning at that position.
# 使用可选启动，测试S从该位置开始。
| With optional end, stop comparing S at that position.
# 使用可选结束，停止在该位置比较S。
| suffix can also be a tuple of strings to try.
# 后缀也可以是要尝试的字符串元组。
# print(str_var1.endswith(("a", 'b', 'c')))
expandtabs(self, /, tabsize=8)
| Return a copy where all tab characters are expanded using spaces.
| # 返回使用空格展开所有制表符的副本。(在只有一个字表符时：tabsize 的默认值为8。tabsize值为0到7等效于tabsize=8。tabsize每增加1，原字符串中“t”的空间会多加一个空格。在有多个字表符时，多出的字表符随着tabsize的值发生变化)
"""
str1 = "i love python"
str = "i lovettpython"
print(str1)
print(str)
print(str.expandtabs())#默认值为8
print(str.expandtabs(tabsize=8))
print(str.expandtabs())
print(str.expandtabs(2))
print(str.expandtabs(tabsize=2))
print(str.expandtabs(tabsize=9))
print(str.expandtabs(tabsize=10))
"""
| If tabsize is not given, a tab size of 8 characters is assumed.
# 如果未给定tabsize，则假定tab大小为8个字符。
|
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.
| # 返回在S中找到子字符串sub的最低索引，
# 使sub包含在S[开始：结束]中。可选择的
# 参数start和end被解释为切片表示法。
"""
str_var1 = "abcabcabc"
print(str_var1.find('abc'))
print(str_var1.find('a', 2, 6))
"""
| Return -1 on failure.
| # 故障时返回-1。
format(...)# 格式化字符串统一讲
| S.format(*args, **kwargs) -> str
|
| Return a formatted version of S, using substitutions from args and kwargs.
# 使用args和kwargs中的替换返回S的格式化版本。
| 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
|
| Return the lowest index in S where substring sub is found,
# 返回在S中找到子字符串sub的最低索引，
"""
str_var1 = "abcabcabc"
print(str_var1.index('abc'))
print(str_var1.index('a', 2, 6))
"""
| such that sub is contained within S[start:end]. Optional
# 使sub包含在S[开始：结束]中。可选择的
| arguments start and end are interpreted as in slice notation.
| # 参数start和end被解释为切片表示法。
| Raises ValueError when the substring is not found.
# 找不到子字符串时引发ValueError。
isalnum(self, /)
| Return True if the string is an alpha-numeric string, False otherwise.
| # 如果字符串是字母数字字符串，则返回True，否则返回False。
"""
str_var1 = "qwe12"
str_var2 = "qwe"
str_var3 = "123"
str_var4 = "+++"
print(str_var1.isalnum()) # True
print(str_var2.isalnum()) # True
print(str_var3.isalnum()) # True
print(str_var4.isalnum()) # False
"""
| A string is alpha-numeric if all characters in the string are alpha-numeric and
| there is at least one character in the string.
| # 如果字符串中的所有字符都是字母数字，并且字符串中至少有一个字符。
isalpha(self, /)
| Return True if the string is an alphabetic string, False otherwise.
| # 如果字符串是字母字符串，则返回True，否则返回False。
"""
str_var3 = "123"
str_var2 = "qwe"
print(str_var3.isalpha()) # False
print(str_var2.isalpha()) # True
"""
| A string is alphabetic if all characters in the string are alphabetic and there
| is at least one character in the string.
# 如果字符串中的所有字符都是字母，并且字符串中至少有一个字符。
isascii(self, /)
| Return True if all characters in the string are ASCII, False otherwise.
| # 如果字符串中的所有字符都是ASCII，则返回True，否则返回False。
"""
str_var1 = "49"
str_var2 = "中文"
print(str_var1.isascii()) # True
print(str_var2.isascii()) # False
"""
| ASCII characters have code points in the range U+0000-U+007F.
# ASCII字符的代码点范围为U+0000-U+007F。
| Empty string is ASCII too.
| # 空字符串也是ASCII。
isdecimal(self, /)
| Return True if the string is a decimal string, False otherwise.
| # 如果字符串是十进制字符串(0~9)，则返回True，否则返回False。
"""
str_var1 = "134577309285"
print(str_var1.isdecimal())
"""
| A string is a decimal string if all characters in the string are decimal and
| there is at least one character in the string.
# 如果字符串中的所有字符都是十进制字符，并且该字符串为十进制字符串字符串中至少有一个字符。
|
isdigit(self, /)
| Return True if the string is a digit string, False otherwise.
| # 如果字符串是数字字符串，则返回True，否则返回False。
"""
str_var1 = "134577309285"
print(str_var1.isdecimal())
"""
| A string is a digit string if all characters in the string are digits and there
| is at least one character in the string.
| # 如果字符串中的所有字符都是数字，并且字符串中至少有一个字符。
isidentifier(self, /)
| Return True if the string is a valid Python identifier, False otherwise.
| # 如果字符串是有效的Python标识符，则返回True，否则返回False。
"""
str_var1 = "for"
print(str_var1.isidentifier())
"""
| Call keyword.iskeyword(s) to test whether string s is a reserved identifier,
# Call关键字。iskeyword测试字符串s是否为保留标识符，
| such as "def" or "class".
| # 例如“def”或“class”。
islower(self, /)
| Return True if the string is a lowercase string, False otherwise.
| # 如果字母字符串是小写字符串，则返回True，否则返回False。
"""
str_var1 = "for"
str_var2 = "For"
str_var3 = "123"
print(str_var1.islower())
print(str_var2.islower())
print(str_var3.islower())
"""
| A string is lowercase if all cased characters in the string are lowercase and
| there is at least one cased character in the string.
| # 如果字符串中的所有字母字符都是小写的，则字符串是小写的，并且字符串中至少有一个字母字符。
isnumeric(self, /)
| Return True if the string is a numeric string, False otherwise.
| # 如果字符串是数字字符串，则返回True，否则返回False。
"""
str_var1 = "for"
str_var2 = "For"
str_var3 = "123"
print(str_var1.isnumeric())
print(str_var2.isnumeric())
print(str_var3.isnumeric())
"""
| A string is numeric if all characters in the string are numeric and there is at
| least one character in the string.
# 如果字符串中的所有字符都是数字，并且字符串中至少有一个字符。
isprintable(self, /)
| Return True if the string is printable, False otherwise.
| # 如果字符串可打印，则返回True，否则返回False。
# 非打印字符是指在 Unicode 字符数据库中定义为“其他”或“分隔符”的字符，但 ASCII 空格（0x20）除外，它被认为是可打印的。（请注意，此上下文中的可打印字符是在对字符串调用 repr( ) 时不应转义的字符。它与写入的字符串的处理无关系统标准输出或者系统标准。)
"""
str_var3 = "123"
print(str_var1.isprintable())
c = 'dqtddqnn'
print(c)
print(c.isprintable())
"""
| A string is printable if all of its characters are considered printable in
| repr() or if it is empty.
| # 如果字符串的所有字符都可以在中打印，则该字符串是可打印的repr（）或如果为空。
isspace(self, /)
| Return True if the string is a whitespace string, False otherwise.
| # 如果字符串是空白字符串，则返回True，否则返回False。
"""
str_var1 = " "
str_var2 = "For"
print(str_var1.isspace())
print(str_var2.isspace())
"""
| A string is whitespace if all characters in the string are whitespace and there
| is at least one character in the string.
| # 如果字符串中的所有字符都是空白，并且字符串中至少有一个字符。
istitle(self, /)
| Return True if the string is a title-cased string, False otherwise.
| # 如果字符串是以标题为大小写的字符串，则返回True，否则返回False。
"""
str_var1 = "Hello Word!"
print(str_var1.istitle())
"""
| In a title-cased string, upper- and title-case characters may only
| follow uncased characters and lowercase characters only cased ones.
| # 在标题大小写字符串中，大写和标题大小写字符只能遵循无大小写字符和小写字符，仅遵循大小写字符。
isupper(self, /)
| Return True if the string is an uppercase string, False otherwise.
| # 如果字符串为大写字符串，则返回True，否则返回False。
"""
str_var1 = "Hello"
str_var2 = "HELLO"
print(str_var1.isupper())
print(str_var2.isupper())
"""
| A string is uppercase if all cased characters in the string are uppercase and
| there is at least one cased character in the string.
| # 如果字符串中所有大小写字符均为大写，则字符串为大写，并且字符串中至少有一个大小写字符。
join(self, iterable, /)
| Concatenate any number of strings.
| # 串联任意数量的字符串。
"""
list_var = ['qw', 'wer', 'asd']
str_var1 = "Hello"
str_var2 = str_var1.join(list_var)
print(str_var2)
"""
| The string whose method is called is inserted in between each given string.
# 调用其方法的字符串插入到每个给定字符串之间。
| The result is returned as a new string.
| # 结果将作为新字符串返回。
| Example: '.'.join(['ab', 'pq', 'rs']) -> 'ab.pq.rs'
| #示例：“.”。加入（['ab'，pq'，rs']）->'ab.pq。卢比'
ljust(self, width, fillchar=' ', /)
| Return a left-justified string of length width.
| # 返回长度宽度为左对齐的字符串。
"""
str_var1 = "Hello"
print(str_var1.ljust(10, '*'))
"""
| Padding is done using the specified fill character (default is a space).
# 填充是使用指定的填充字符完成的（默认为空格）。
|
lower(self, /)
| Return a copy of the string converted to lowercase.
| # 返回转换为小写的字符串的副本。
"""
str_var1 = "Hello"
print(str_var1.lower())
"""
lstrip(self, chars=None, /)
| Return a copy of the string with leading whitespace removed.
| # 返回删除前导空格的字符串副本。
"""
str_var1 = "***Hello"
print(str_var1.lstrip("*"))
"""
| If chars is given and not None, remove characters in chars instead.
| # 如果给定了chars而不是None，请删除chars中的字符。
partition(self, sep, /)
| Partition the string into three parts using the given separator.
| # 使用给定的分隔符将字符串分为三部分。
"""
str_var1 = "7+8"
print(str_var1.partition("+"))
"""
| This will search for the separator in the string. If the separator is found,
| returns a 3-tuple containing the part before the separator, the separator
| itself, and the part after it.
| # 这将在字符串中搜索分隔符。如果找到分隔符，返回一个3元组，其中包含分隔符之前的部分，分隔符它本身和它后面的部分。
| If the separator is not found, returns a 3-tuple containing the original string
| and two empty strings.
| # 如果未找到分隔符，则返回包含原始字符串的3元组，和两个空字符串。
replace(self, old, new, count=-1, /)
| Return a copy with all occurrences of substring old replaced by new.
| # 返回一个副本，其中所有出现的子字符串旧替换为新。
"""
str_var1 = "7+8"
print(str_var1.replace("+", "/"))
"""
| count
| Maximum number of occurrences to replace.
# 要替换的最大出现次数。
| -1 (the default value) means replace all occurrences.
| # -1（默认值）表示替换所有引用。
| 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,
# 返回在S中找到子字符串sub的最高索引，
"""
str_var1 = "abcabcbac"
print(str_var1.rfind("abc"))
# 3
"""
| such that sub is contained within S[start:end]. Optional
# 使sub包含在S[开始：结束]中。可选择的
| arguments start and end are interpreted as in slice notation.
| # 参数start和end被解释为切片表示法。
| Return -1 on failure.
| # 故障时返回-1。
rindex(...)
| S.rindex(sub[, start[, end]]) -> int
|
| Return the highest index in S where substring sub is found,
# 返回在S中找到子字符串sub的最高索引，
"""
str_var1 = "abcabcbac"
print(str_var1.rindex("abc"))
# 3
"""
| such that sub is contained within S[start:end]. Optional
# 使sub包含在S[开始：结束]中。可选择的
| arguments start and end are interpreted as in slice notation.
| # 参数start和end被解释为切片表示法。
| Raises ValueError when the substring is not found.
| # 找不到子字符串时引发ValueError。
rjust(self, width, fillchar=' ', /)
| Return a right-justified string of length width.
| # 返回长度-宽度为右对齐的字符串。
"""
str_var1 = "Hello"
print(str_var1.rjust(10, '*'))
"""
| Padding is done using the specified fill character (default is a space).
| # 填充是使用指定的填充字符完成的（默认为空格）。
rpartition(self, sep, /)
| Partition the string into three parts using the given separator.
| # 使用给定的分隔符将字符串分为三部分。
"""
str_var1 = "7+8"
print(str_var1.rpartition("+"))
"""
| This will search for the separator in the string, starting at the end. If
| the separator is found, returns a 3-tuple containing the part before the
| separator, the separator itself, and the part after it.
| # 这将在字符串中搜索分隔符，从末尾开始。如果如果找到分隔符，则返回一个3元组，其中包含分隔符之前、分隔符本身及其后面的部分。
| If the separator is not found, returns a 3-tuple containing two empty strings
| and the original string.
| # 如果未找到分隔符，则返回包含两个空字符串的3元组和原始字符串。
rsplit(self, /, sep=None, maxsplit=-1)
| Return a list of the words in the string, using sep as the delimiter string.
| # 使用sep作为分隔符字符串，返回字符串中的单词列表(从结尾开始计数)。
"""
str_var1 = "7+8"
print(str_var1.split(sep="+"))
"""
| sep
| The delimiter according which to split the string.
# 分割字符串所依据的分隔符。
| None (the default value) means split according to any whitespace,
# None（默认值）表示根据任何空格进行拆分，
| and discard empty strings from the result.
# 并从结果中丢弃空字符串。
| maxsplit
| Maximum number of splits to do.
# 要执行的最大拆分数。
| -1 (the default value) means no limit.
| # -1（默认值）表示没有限制。
| Splits are done starting at the end of the string and working to the front.
| # 拆分从字符串的末尾开始，一直到前面。
rstrip(self, chars=None, /)
| Return a copy of the string with trailing whitespace removed.
| # 返回删除尾部空格的字符串副本。
"""
str_var1 = "7+8*****"
print(str_var1.rstrip("*"))
"""
| If chars is given and not None, remove characters in chars instead.
| # 如果给定了chars而不是None，请删除chars中的字符。
split(self, /, sep=None, maxsplit=-1)
| Return a list of the words in the string, using sep as the delimiter string.
| # 使用sep作为分隔符字符串，返回字符串中的单词列表。
| sep
| The delimiter according which to split the string.
| None (the default value) means split according to any whitespace,
| and discard empty strings from the result.
# 分割字符串所依据的分隔符。
# 并从结果中丢弃空字符串。
# None（默认值）表示根据任何空格进行拆分，
| maxsplit
| Maximum number of splits to do.
| -1 (the default value) means no limit.
| # 要执行的最大拆分数。
# -1（默认值）表示没有限制。
splitlines(self, /, keepends=False)
| Return a list of the lines in the string, breaking at line boundaries.
| # 返回字符串中的行列表，在行边界处打断。
"""
str_var1 = "7+8*****nqweqwedas"
print(str_var1.splitlines())# ['7+8*****', 'qweqwedas']
"""
| Line breaks are not included in the resulting list unless keepends is given and
| true.
| #结果列表中不包括换行符，除非给出了keepends，并且为真
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.
"""
如果S以指定前缀开头，则返回True，否则返回False。
使用可选启动，测试S从该位置开始。
使用可选结束，停止在该位置比较S。
前缀也可以是要尝试的字符串元组。
"""
|
strip(self, chars=None, /)
| Return a copy of the string with leading and trailing whitespace removed.
| # 返回删除前导和尾随空格的字符串副本。
| If chars is given and not None, remove characters in chars instead.
| # 如果给定了chars而不是None，请删除chars中的字符。
swapcase(self, /)
| Convert uppercase characters to lowercase and lowercase characters to uppercase.
| # 将大写字符转换为小写，将小写字符转换为大写。
"""
str_var1 = "HEllo"
print(str_var1.swapcase())
"""
title(self, /)
| Return a version of the string where each word is titlecased.
| # 返回每个单词标题所在的字符串版本。
"""
str_var1 = "hello word"
print(str_var1.title())
"""
| More specifically, words start with uppercased characters and all remaining
| cased characters have lower case.
| # 更具体地说，单词以大写字符开头，其余所有字符大小写字符使用小写。
translate(self, table, /)
| Replace each character in the string using the given translation table.
| # 使用给定的翻译表替换字符串中的每个字符。
"""
s = 'ABCDBCA'
print(s.translate({ord('A'): ord('a'), ord('B'): ord('b'), ord('C'): None}))
print(s.translate({ord('A'): 'X', ord('B'): 'YZ', ord('C'): None}))
"""
| table
| Translation table, which must be a mapping of Unicode ordinals to
| Unicode ordinals, strings, or None.
| # 转换表，它必须是Unicode序号到的映射,Unicode序号、字符串或无。
| The table must implement lookup/indexing via __getitem__, for instance a
| dictionary or list. If this operation raises LookupError, the character is
| left untouched. Characters mapped to None are deleted.
| # 该表必须通过uu getitemuuuuu实现查找/索引，例如字典或列表。如果此操作引发LookupError，则字符为保持不变。将删除映射到“无”的字符。
| upper(self, /)
| Return a copy of the string converted to uppercase.
# 返回转换为大写的字符串的副本。
|
zfill(self, width, /)
| Pad a numeric string with zeros on the left, to fill a field of the given width.
| # 在左侧用零填充数字字符串，以填充给定宽度的字段。
"""
str_var = "123"
print(str_var.zfill(10))
"""
| The string is never truncated.
# 字符串永远不会被截断。
4、格式化输出：
姓名 年龄 性别 家庭住址
xxx xxx
list_data = [{name: xxx, age: xxx, gender: xxx, address}, .....]
包含居中对齐，向左对齐， 向右对齐
print("{:^5}t{:^5}t{:^5}t{:^30}".format("姓名", "年龄", "性别", "家庭住址"))
list_data = [{"name": "王海林", "age": 19, "gender": "男", "address": "陕西省汉中市宁强县"},
{"name": "王海林", "age": 19, "gender": "男", "address": "陕西省汉中市宁强县"},
{"name": "王海林", "age": 19, "gender": "男", "address": "陕西省汉中市宁强县"}]
print("{name:^5}t{age:^5}t{gender:^5}t{address:^30}".format_map(list_data[0]))
print("{name:<5}t{age:<5}t{gender:<5}t{address:<30}".format_map(list_data[1]))
print("{name:>5}t{age:>5}t{gender:>5}t{address:>30}".format_map(list_data[2]))
