变量和格式化输出

Python采用基于值的内存管理模式。赋值语句的执行过程是：首先把等号右侧表达式的值计算出来，然后在内存中寻找一个位置把值放进去，最后创建变量并指向这个内存地址。Python中的变量并不直接存储值，而是存储了值的内存地址或者引用，这也是变量类型随时可以改变的原因。

变量用于引用在程序中可能会变化的值。

1，变量

In [2]: name1='apple'

In [3]: name2='apple'

In [4]: id(name1)
Out[4]: 1438115923984

In [5]: id(name2)
Out[5]: 1438115923984  name1和name2的内存地址一样的 这是Python的内存优化机制

In [6]: name1="i love you"

In [7]: name2="i love you"

In [8]: id(name1)
Out[8]: 1438129390000

In [9]: id(name2)
Out[9]: 1438129393456  此时name1与name2的内存地址就不同了 对长字符串没有内存优化机制

In [21]: name1=1000

In [22]: name2=1000

In [23]: id(name1)
Out[23]: 1438129513968

In [24]: id(name2)
Out[24]: 1438129513616  数字在[-5,257)之间才有内存优化（只开出一个地址空间来）

In [25]: name1=name2=1000

In [26]: id(name1)
Out[26]: 1438129512784

In [27]: id(name2)
Out[27]: 1438129512784  连续赋值时就是相当于两个相同的指针指向内存地址，我认为一个钥匙上挂了两个环

2，格式化输出 字符串格式化输出还是字符形式的

input（）函数的输出默认是字符串格式的

def format(*args, **kwargs): # real signature unknown
    """
    Return value.__format__(format_spec)
    
    format_spec defaults to the empty string
    """
    pass

format（item,format-specifier） item是数字或者字符串，而格式说明符（format-specifier）指定条目item的格式。此函数返回一个字符串。

例如10.2f  其中10指域宽度     .2指精度   f指转换码    整体就是一个格式符。

In [32]: format(12.1512345,'10.2f')  
Out[32]: '     12.15'                         小数点是一位的，默认右对齐，四舍五入

In [33]: format(23.2456453,'10.2f')
Out[33]: '     23.25'

In [34]: format(12.3,"10.2f")     位数不够补0
Out[34]: '     12.30'

In [35]: format(23.23456,'.3f')   没有指定宽度根据内容来自动设置的 .n用来指定精度
Out[35]: '23.235'

In [36]: format(12345678.901,'10.1f')
Out[36]: '12345678.9'

In [37]: format(12345678.901,'10.2f')  超出了宽度，保证内容优先，增加了宽度
Out[37]: '12345678.90'

In [39]: format(585.58558,'10.3e')  科学计数法
Out[39]: ' 5.856e+02'

In [40]: format(0.0585858,'10.2%') 百分数
Out[40]: '     5.86%'

In [41]: format(0.5989898,'.3%')
Out[41]: '59.899%'

In [42]: format(0.0585858,'<10.2%') <左对齐 在格式符的比较前的位置
Out[42]: '5.86%     '

In [43]: format(12,'d')  十进制  格式化整数
Out[43]: '12'

In [44]: format(12,'x')  十六进制
Out[44]: 'c'

In [45]: format(12,'o')   八进制
Out[45]: '14'

In [47]: format(12,"b") 二进制
Out[47]: '1100'

In [48]: format('we will regain the lost after we lost it','<45s')
Out[48]: 'we will regain the lost after we lost it     '             指定45为宽度
           
In [49]: format('we will regain the lost after we lost it','45s') 数字默认右对齐，而字符串是默认的左对齐
Out[49]: 'we will regain the lost after we lost it     '

In [50]: format('we will regain the lost after we lost it','>45s')
Out[50]: '     we will regain the lost after we lost it'            对齐方式要和宽度配合用

%

In [53]: from math import pi

In [54]: 'pi%i'%pi  i和d都是十进制
Out[54]: 'pi3'

In [55]: '%.5f'%pi
Out[55]: '3.14159'


In [58]: '%10.3f'%pi
Out[58]: '     3.142'

字符串格式化的方法str.format()，基本语法是通过{}和：来代替之前的%

In [3]: "{}{}".format('hello','world')
Out[3]: 'helloworld'

In [4]: '{}   {}'.format('hello','world')
Out[4]: 'hello   world'


In [6]: '{1}{0}{0}{1}'.format('hello','world')
Out[6]: 'worldhellohelloworld'

In [7]: 'name:{name},age:{age}'.format(name="Tom",age="28")
Out[7]: 'name:Tom,age:28'


In [9]: 'name:{name},age:{age}'.format(age="28",name="Tom",)   
Out[9]: 'name:Tom,age:28'

In [10]: '{:.2f}'.format(3.1415926)
Out[10]: '3.14'

In [11]: '{:_}'.format(10000000)
Out[11]: '10_000_000'

In [14]: "{:^10f}".format(5678.2)
Out[14]: '5678.200000'

In [15]: "{:>10f}".format(5678.2)  貌似浮点数不好改变位置，貌似字符串的format方法的是左开头 str.format()；函数format()是右开头
Out[15]: '5678.200000'

In [17]: '{:b}'.format(11)
Out[17]: '1011'

In [20]: "{:x}".format(11)
Out[20]: 'b'

In [60]: "{:^10d}".format(12345)
Out[60]: '  12345   '

In [61]: "{:10d}".format(12345)
Out[61]: '     12345'

In [62]: "{:<10d}".format(12345)
Out[62]: '12345     '              整数就是默认的右开头，可以调整位置

[[fill]align][sign][#][0][width][,][.precision][type]

• fill           【可选】空白处填充的字符
• align        【可选】对齐方式（需配合width使用）
• <，内容左对齐
• >，内容右对齐(默认)
• ＝，内容右对齐，将符号放置在填充字符的左侧，且只对数字类型有效。 即使：符号+填充物+数字
• ^，内容居中
• sign         【可选】有无符号数字
  • +，正号加正，负号加负；
  •  -，正号不变，负号加负；
  • 空格 ，正号空格，负号加负；
• #            【可选】对于二进制、八进制、十六进制，如果加上#，会显示 0b/0o/0x，否则不显示
• ，            【可选】为数字添加分隔符，如：1,000,000
• width       【可选】格式化位所占宽度
• .precision 【可选】小数位保留精度
• type         【可选】格式化类型
  • 传入” 字符串类型 “的参数
    • s，格式化字符串类型数据
    • 空白，未指定类型，则默认是None，同s
  • 传入“ 整数类型 ”的参数
    
    • b，将10进制整数自动转换成2进制表示然后格式化
    • c，将10进制整数自动转换为其对应的unicode字符
    • d，十进制整数
    • o，将10进制整数自动转换成8进制表示然后格式化；
    • x，将10进制整数自动转换成16进制表示然后格式化（小写x）
    • X，将10进制整数自动转换成16进制表示然后格式化（大写X）
  • 传入“ 浮点型或小数类型 ”的参数
    • e， 转换为科学计数法（小写e）表示，然后格式化；
    • E， 转换为科学计数法（大写E）表示，然后格式化;
    • f ， 转换为浮点型（默认小数点后保留6位）表示，然后格式化；
    • F， 转换为浮点型（默认小数点后保留6位）表示，然后格式化；
    • g， 自动在e和f中切换
    • G， 自动在E和F中切换
    • %，显示百分比（默认显示小数点后6位）

In [22]: "---{:#^25}".format("water")
Out[22]: '---##########water##########'

In [32]: "{2:.2f}--{0:,}---{1:<10}".format(12234234,5000,12345.234)
Out[32]: '12345.23--12,234,234---5000      '

 补充

In [33]: tp7 = "i am {0[0]}, age {0[1]}, really {0[2]}".format([1, 2, 3], [11, 22, 33])

In [34]: print(tp7)
i am 1, age 2, really 3

In [35]: tp7 = "i am {1[0]}, age {1[1]}, really {1[2]}".format([1, 2, 3], [11, 22, 33])

In [36]: print(tp7)
i am 11, age 22, really 33

In [37]: tp7 = "i am {0[0]}, age {0[1]}, really {0[2]}".format([1, 2, 3])

In [38]: print(tp7)
i am 1, age 2, really 3

In [39]: tp7 = "i am {[0]}, age {[1]}, really {[2]}".format([1, 2, 3])
Traceback (most recent call last):

  File "<ipython-input-39-6064c0aa6d92>", line 1, in <module>
    tp7 = "i am {[0]}, age {[1]}, really {[2]}".format([1, 2, 3])

IndexError: tuple index out of range
 第一个0不能少

tp1 = "i am {}, age {}, {}".format("seven", 18, 'alex')
tp2 = "i am {}, age {}, {}".format(*["seven", 18, 'alex'])
tp3 = "i am {0}, age {1}, really {0}".format("seven", 18)
tp4 = "i am {0}, age {1}, really {0}".format(*["seven", 18])
tp5 = "i am {name}, age {age}, really {name}".format(name="seven", age=18)
tp6 = "i am {name}, age {age}, really {name}".format(**{"name": "seven", "age": 18})
tp7 = "i am {0[0]}, age {0[1]}, really {0[2]}".format([1, 2, 3], [11, 22, 33])
tp8 = "i am {:s}, age {:d}, money {:f}".format("seven", 18, 88888.1)
tp9 = "i am {:s}, age {:d}".format(*["seven", 18])
tp10 = "i am {name:s}, age {age:d}".format(name="seven", age=18)
tp11 = "i am {name:s}, age {age:d}".format(**{"name": "seven", "age": 18})
print(tp1)
print(tp2)
print(tp3)
print(tp4)
print(tp5)
print(tp6)
print(tp7)
print(tp8)
print(tp9)
print(tp10)
print(tp11)

1i am seven, age 18, alex
2i am seven, age 18, alex
3i am seven, age 18, really seven
4i am seven, age 18, really seven
5i am seven, age 18, really seven
6i am seven, age 18, really seven
7i am 1, age 2, really 3
8i am seven, age 18, money 88888.100000
9i am seven, age 18
10i am seven, age 18
11i am seven, age 18

In [42]: "I am {:.2f} years old".format(*[12.156,34.567])
Out[42]: 'I am 12.16 years old'

In [43]: "I am {1:.2f} years old".format(*[12.156,34.567])
Out[43]: 'I am 34.57 years old'

In [46]: "I am {1[0]:.2f} years old".format([12.156],[34.567])
Out[46]: 'I am 34.57 years old'

In [47]: "I am {1[1]:.2f} years old".format([12.156,1,2],[34.567,23.11,345,1])
Out[47]: 'I am 23.11 years old'

不涉及形式改变的化，是不用：的

In [50]: q1=18

In [51]: type(q1)
Out[51]: int

In [52]: q1='{:d}'.format(18)

In [53]: type(q1)
Out[53]: str       数字18进过字符串格式化后变成了一个看上去像数字的字符“18”

In [55]: 'my name is {name2}'.format(**{"name1":"Tom",'name2':"lufy"})
Out[55]: 'my name is lufy'

In [56]: 'my name is {name2}'.format({"name1":"Tom",'name2':"lufy"})
Traceback (most recent call last):

  File "<ipython-input-56-cbc3db666587>", line 1, in <module>
    'my name is {name2}'.format({"name1":"Tom",'name2':"lufy"})

KeyError: 'name2'   字典必须要加**，我认为啊*从列表降到字符，**从字典降到字符，要么就在format后面的括号中用等号指定