11.Python数据引用&输入&格式化输出

1.引用

引用:访问值的方式都称为引用.

栈区：存放是变量名与内存地址的对应关系，所以可以简单理解为：变量名存内存地址
堆区：存放的是变量值

1.1直接引用

变量名直接指向内存地址中的值.

x = 1
y = x
print(x)  # 直接引用
print(y)  # 直接引用

变量名的赋值（x = y），还有变量名的传参（print(x)），传递的都是栈区的数据
，而且栈的数据是变量名与内存地址的对应关系，或者说是对值的引用.

1.2间接引用

间接引用只要针对的是容器类型.
如容器类型列表,它指向的是一个列表的索引
索引指向存放的值,索引相当于值的内存地址,通过索引访问值,这是间接引用.

x = 1
list1 = ['x', x]  # 间接引用

1.3修改值

y 指向 x 指向的值.
y 与 x 同时执行 值10.
修改 x 的值,不会影响y的值.

x = 10
y = x
print(x, y)
print(id(x), id(y))
"""
10 10
1422486560 1422486560
"""

# 修改x的值
x = 11
print(x, y)
"""
11 10
"""

容器类型的中存放的变量绑定新的值,不会影响容器类型的值.

x = 10
list1 = ['a', x]
print(x, list1[1])
print(id(x), id(list1[1]))
"""
10 10
1422486560 1422486560
"""

# 修改值
x = 11
print(x, list1[1])
"""
11 10
"""

2.输入

2.1关键字

关键字：input()

知识点：
1.程序在执行到input时会终端要输用户输入信息，输入信息后，按下回车提交信息，程序继续往下运行。

2.可以在input中写入一段字符串用于提示，在默认情况下就一个光标在闪烁，提示性不不强。

3.input获取的数据可以用一个变量来存储。

2.2阻塞状态

input()
print('hello word')

从下图可以看到知识点1的描述。在遇到input,程序被被阻塞在次,不会往后面运行,
需要输入信息(按下回车确认输入!)后才解除阻塞,继续往下运行。

2.3打印提示信息

input()
print('hello word')
input("你好，请看到这个信息在这里输入你的名称>>>>>：")
print('久等了···')

从下图可以看到知识点2的描述。没有描述信息的话，输入全靠猜，在设置提示之后，简单明了。

2.4获取输入

name = input("你好，请看到这个信息在这里输入你的名称>>>>>：")
print(name)

从下图可以看到知识点3的描述。获取数据可以赋值给一个变量,
使用变量将值存储之后就行在程序中使用。

3.版本差异

Python2与Python3输入的存在着差异。
Python3 所有的输入被被转换为字符串类型。
python2 中输入是什么数据，变量就是什么数据类型。
---------------------------------------------
python3的的中的input其实是python2中的raw_input()。
raw_input() 直接读取控制台的输入，任何类型的输入它都可以接收。

3.1Python3输入

str1 = input('请在这个输入：')
print(str1, type(str1))

请在这个输入：1
1 <class 'str'>
请在这个输入：[1,2,3]
[1,2,3] <class 'str'>
···

3.2Python2输入

1.input

* 切换编译环境2.7

str1 = input('input>>>:')
print(str1, type(str1))

input>>>:1
(1, <type 'int'>)
input>>>:[1, 2,]
([1, 2], <type 'list'>)

2.raw_input

str1 = raw_input('input>>>:')
print(str1, type(str1))

input>>>:1
('1', <type 'str'>)
input>>>:[1,2]
('[1,2]', <type 'str'>)

4.输出

4.1格式

关键字：print() 会打印括号内的数据。
如果是纯数字可以省略括号.
参数：
value：可以同时输出多个对象，对象之间，使用,逗号隔开。
sep：  多个对象的间隔距离，默认是一个空格，支持自定义。
end：  设置输出的结尾符号，默认为换行符，支持自定义。

4.2多个对象

print(1, 2, 3)
print 1, 2, 3
# 1 2 3
# 1,2,3

4.3间隔

默认有一个空格。
通过sep参数自定义间隔符号。

print(1, 2, 3, sep=' ')  # 默认
print(1, 2, 3, sep='')
print(1, 2, 3, sep='+')

"""
1 2 3
123
1+2+3
"""

4.4结尾符

默认结尾符为\n换行符。

print(1)
print(2)
print(3)
"""
1
2 
3
"""

可以通过end参数自定义结尾符。

print(0, end='\n')
print(1, end='')
print(2, end='*')
print(3, end='+')

"""
0
12*3+
"""

4.5快捷写法

在Pycharm中打印字符串的快捷写法。
'字符串'.print tab

5.格式化输出

将字符串中某些内容进行替换，再输出。
格式化输入原理：利用占位符，先占位在把传值，不要多传，也不要少传。

5.1%格式

% 百分号为占位符，先占位，在以对应类型输入。
%s 以字符类型输出，（任何类型可以转换成字符串来输出）。
%d 以整型输出。

单个占位符格式：
print('%6d' % 123456)

多个单个占位符格式
print('%s xxxx %d xxx ····' % (填补第一个占位元素, 填补第二个占位元素 ····))
前面为字符串 中间百分号 (元素···)

name = 'kid'
age = 18
# 按顺序替换不对传不少传
print('%s 今年 %d 岁' % (name, age))  
print('%s 今年 %s 岁' % (name, age))

# 以字典的形式传值，打破位置的限制
res = "我的名字是 %(name)s 我的年龄是 %(age)s" % {"age":"18","name":'kid'}
print(res)
# 我的名字是 kid 我的年龄是 18

# %s可以接收任意类型
print('my age is %s' %18)
print('my age is %s' %[1,23])
print('my age is %s' %{'a':333})
print('my age is %d' %18) # %d只能接收int
print('my age is %d' %"18")

# 元组比较特殊
print('%s %s' % (1, 2))  # (1, 2) 是一个元组
t1 = 1, 2
print('%s %s' % t1)  # 元组使用%s，被看成传入了 元素的个数 个参数
"""
1 2
1 2
"""

t1 = 1, 2
print(t1, type(t1))
print('%s' % t1)
"""
TypeError: not all arguments converted during string formatting
TypeError：字符串格式化期间并非所有参数都转换了
"""
print('%s' % t1[0])
print('%s' % t1[1])
"""
1
2
"""

5.2format格式

format格式传值Python3中才支持.
官方推荐的格式!

# 按照位置传值
res = '我的名字是 {} 我的年龄是 {}'.format('kid', 18)
print(res)

# 按索引传参
res = '我的名字是 {0} {0} {0} 我的年龄是 {1} {1}'.format('kid', 18)
print(res)

# 按名称传参
age = 18
res = '我的名字是 {name} {name} {name} 我的年龄是 {age} {age}'.format(name='kid', age=age)
print(res)

"""
我的名字是 kid 我的年龄是 18
我的名字是 kid kid kid 我的年龄是 18 18
我的名字是 kid kid kid 我的年龄是 18 18
"""

5.3f格式

Python3.5开始才推出
按变量名称去匹配值.

name = 'qq'
age = 18
print(f'{name} {name} {age} {age}')  # qq qq 18 18

"""
kid 今年 18 岁
kid 今年 18 岁
"""

5.4格式说明

转换说明符	解释
%d、%i	转换为带符号的十进制整数
%o	转换为带符号的八进制整数
%x、%X	转换为带符号的十六进制整数
%e	转化为科学计数法表示的浮点数（e 小写）
%E	转化为科学计数法表示的浮点数（E 大写）
%f、%F	转化为十进制浮点数
%g	智能选择使用 %f 或 %e 格式
%G	智能选择使用 %F 或 %E 格式
%c	格式化字符及其 ASCII 码
%r	使用 repr() 函数将表达式转换为字符串
%s	使用 str() 函数将表达式转换为字符串

5.5字符宽度

设置输出字符的宽度，值为数字。
格式：
% 填充字符 字段宽度 输出的类型 
%06d   表示： 一共6位，位数不够0来凑。
%m.nf 表示： 一共m位，小数部分占n位。(m 表示最小宽度，n 表示输出精度，
.是必须存在的,也算以为)

标志	说明
-	指定左对齐
+	输出的数字总要带着符号；正数带+，负数带-。
0	宽度不足时：数字类型补充 0，字符类型补充空格。

print('%06d' % 1)  # 000001
print('%6d' % 123)  # 123
print('%6d' % 12345678)  # 超出正常显示
print('%10.6f' % 123.456)  # 123.456000 浮点型默认填充0
print("123%03s56" % 4)  # 123  456 两个空格

5.6填充/对齐

先取到值,然后在冒号后设定填充格式：[指定的填充字符][对齐方式][宽度]
填充字符默认不写就是空格
齐方式:
< 左对齐
> 右对齐
^ 居中

#  *<10：左对齐，总共10个字符，不够的用*号填充
print('{0:*<10}'.format('开始执行'))  
# 开始执行******

# *>10：右对齐，总共10个字符，不够的用*号填充
print('{0:*>10}'.format('开始执行'))  
# ******开始执行

# *^10：居中显示，总共10个字符，不够的用*号填充
print('{0:*^10}'.format('开始执行')) 
# ***开始执行***

5.7精度与进制

# 精确到小数点后3位，四舍五入，结果为：1232132.124
print('{salary:.3f}'.format(salary=1232132.12351)) 

# 转成二进制，结果为：1111011
print('{0:b}'.format(123))  

# 转成八进制，结果为：11
print('{0:o}'.format(9))  

# 转成十六进制，结果为：f
print('{0:x}'.format(15))  

 # 千分位格式化，结果为：99,812,939,393,931
print('{0:,}'.format(99812939393931)) 

6.转义

6.1专义字符

转义字符	说明
\n	换行符，将光标位置移到下一行开头。
\r	回车符，将光标位置移到本行开头。
\t	水平制表符，也即 Tab 键，一般相当于四个空格。
\a	蜂鸣器响铃。注意不是喇叭发声，现在的计算机很多都不带蜂鸣器了，所以响铃不一定有效。
\b	退格（Backspace），将光标位置移到前一列。
\	反斜线
’	单引号
"	双引号
\	在字符串行尾的续行符，即一行未完，转到下一行继续写。

6.2覆盖打印案例

覆盖打印:
打印一次,延时1秒,在打印,
sed="" 设置print不换行打印,
\r  将光标位置移到本行开头,再次打印的话将上次的内容覆盖.

# 覆盖打印
import time

for i in range(10):
    print("\r离程序退出还剩%s秒" % (9 - i), end="")
    time.sleep(1)

7.作业

1、简单描述定义一个变量x=10，在内存中的栈区域堆区的存放情况
2.分别画出下面两个列表在内存中是如何存放的
    l1=[11,22,[333,444]]
    l2=[11,22,[33,{'name':'egon','age':18}]]
3.简述什么是直接引用、什么是间接引用
4.写一段程序
接收用户输入的用户名、年龄、性别，然后选取最优格式化字符串的方式，
按照如下格式输出:

    我的名字是：xxx
    我的年龄是：xxx
    我的性别是：xxx


5.用户输入姓名、年龄、工作、爱好 ，然后打印成以下格式
------------ info of Egon -----------
姓名  : KID
年龄   : 22
工作   : XX
爱好   : YY
------------- end -----------------