print( )

• 1, 在print( )函数中，不能使用字符串+数字，如要要用+数字，则数字需要加引号（单/双引号）；
• 2, 默认打印：会自动换到下一行，因为默认后面跟有end=’ \n’)；

print(objects, sep, end, file, flush) 方法：
# objects -> 表示多个输出的对象；
# sep -> 表示多个输出对象直接的分隔符，默认为1个空格；
# end -> 表示输出对象结束符，默认为换行符；
# file -> 表示数据流输出到的文件；参数flush表示数据流输出至文件时是否缓冲，默认为False（不缓冲）；

# 默认打印结果出来后会换行，因为默认后面跟有end=' \n', 打印的模式如下:
print(123, end='\n')
# 如果打印后不需要换行 (既在一行中显示结果，则用逗号间隔，但是需要分多行写入)
print('gznoc.com', end=',')
print(123, end=',')
print(False, end='\n')
# 将多行写在一个print语句里面(注：可以用逗号将字符串和数值链接起来，逗号是一个空格)
print("gznoc.com", 123, False)
# 在字符串或是多个变量中间插入某些分隔符 (使用sep)
str01 = "my"
str02 = 'english name'
print("Terence is", str01, str02, sep='#', end="\n\n")
# 输出到文件
str03 = '本次消费金额为：133元'
file_name = open("/root/test.txt", 'w') 
print(str03, file=file_name)                   # 将str03的内容写入到file_name的目录文件中

print( ) 输出带颜色的字体

常见的开头格式如下:

格式:
\033 [显示方式；前景色；背景色m 需要显示的文字 \033[0m

• \033[ —-> 属于开头部分；
• \033[0m —-> 属于结尾部分；对于结尾部分，其实也可以省略，但是为了书写规范，建议\033[开头 * \033[0m结尾;
• 显示方式；前景色；背景色m —->这三个参数可只写其中的一个；三个参数表示不同的含义，唯一，三个参数没有先后顺序，没有固定要求，建议按照默认格式规范书写;

  print('\033[0m这是显示方式0')
  print('\033[1m这是显示方式1')
  print('\033[4m这是显示方式4')
  print('\033[5m这是显示方式5')
  print('\033[7m这是显示方式7')
  print('\033[8m这是显示方式8')
  print('\033[30m这是前景色0')
  print('\033[31m这是前景色1')
  print('\033[32m这是前景色2')
  print('\033[33m这是前景色3')
  print('\033[34m这是前景色4')
  print('\033[35m这是前景色5')
  print('\033[36m这是前景色6')
  print('\033[37m这是前景色7')
  print('\033[40m这是背景色0')
  print('\033[41m这是背景色1')
  print('\033[42m这是背景色2')
  print('\033[43m这是背景色3')
  print('\033[44m这是背景色4')
  print('\033[45m这是背景色5')
  print('\033[46m这是背景色6')
  print('\033[47m这是背景色7')
  print('\033[1;35;0m字体变色，但无背景色 \033[0m')    # 有高亮 或者 
  print('\033[1;35m字体有色，但无背景色 \033[0m')
  print('\033[1;45m 字体不变色，有背景色 \033[0m')     # 有高亮
  print('\033[1;35;46m 字体有色，且有背景色 \033[0m')  # 有高亮
  print('\033[0;35;46m 字体有色，且有背景色 \033[0m')  # 无高亮

  ```python info = input(“Please Introduce yourself: “)

print(‘\033[1;33mWe asked him to introduce himself first, He said \”%s.\”\033[3;31m’ %info) print(‘这行是上一行结尾的颜色输出效果 ‘)

<a name="55b7bfcb"></a>
### 占位符（百分比%和format）
**百分比%**
| **符号** | **说明** |
| --- | --- |
| %c | 表示字符 |
| %s | 字符串的占位符 |
| %d | 十进制整数的占位符 |
| %f | 浮点数的占位符 |
| %x | 将数字使用十六进制输出（小写字母） |
| %nd | 打印时，显示n位，如果不够，在前面使用空格补齐 |
| %.nf | 保留数点后n位 |
| %X | 十六进制整数输出（大写字母） |
| %% | 输出一个%号 |
| %i | 有符号的十进制整数的占位符 |
| %u | 无符号十进制整数 |
| %o | 八进制整数 |
| %e | 索引符号（小写的e） |
| %E | 索引符号（大写的E） |
| %g | %f和%e的简写 |
| %G | %f和%E的简写 |
**format( )**<br />format( )函数是把字符串当做一个模板，通过传入参数后进行格式化，并且使用大括号{ }来进行占位
| **语法** | **介绍** |
| --- | --- |
| format(args,kwargs) | 对字符串进行格式化的函数； |
|  | 参数args：表示可以输入多个参数（argument），参数间以逗号分隔； |
|  | 参数kwargs：表示可以输入多个关键词参数，关键字函数的写法例如：age='18'，age为关键字，'18'为这个关键字对应的值`` |
```python
id = input('请输入您的身份证号：')
print('您的出生日期为：%s' %id[6:14])
print('您的出生日期为：%s年%s月%s日' %(id[6:10], id[10:12], id[12:14]))
# %s：是一个格式符，其中“s”表示字符串，也就是说，%s表示这个格式符所在的位置内容必须用字符串替代；
# 接下来的“%”表示需要进行格式化的操作，也就是说，要把这个符号后方的内容替换掉前面的“%s”，最终来形成我们想要的字符串内容；

字符串的格式化输出

a = 'abcdefg'
b = 123
print('%s' %a)                          # %s:标准输出
print('%-10s' %a)                       # %10s:左对齐，占位符10位
print('%10s' %a)                        # %10s:右对齐，占位符10位
print('%.3s' %a)                        # %.2s:截取3位字符
print('%10.4s' %a)                      # %10.2s:10位占位符，截取左边4位字符
print('%10.3s' %a[-3:])                 # 10位占位符，截取右边3位字符
print('%s的前三位对应数字为:%d' %(a,b))    # 符串不能和数字直接相加,使用%s(占据一个字符串位)和%d(占据一个整数位)先占据一个位置,然后将变量调用进来

整数格式化输出

a = 100
print('二进制为:',bin(a))                         # 使用二进制输出:bin()，需要用逗号隔开
print('八进制为:%o' %a)                           # 八进制输出使用:%o，不需要用逗号隔开
print('十进制为:%d' %a)                           # 十进制输出使用:%d，不需要用逗号隔开
print('十六进制为:%x' %a)                       # 十六进制输出使用:%x，不需要用逗号隔开
print('八进制输出为:%o十进制为:%d' %(a,a))          # 多参数打印一行
print('八进制输出为:%o\n十进制为:%d\n' %(a,a))      # 多参数分两行打印

浮点数格式化输出

a=3.1415926
print('四舍五入后保留三位小数:',round(a,3))                   # 保留小数位:round()，注意，如果要保留的小数位不够，不会补0（这是与%.3f使用的区别）
print('保留小数点后面6位小数:%f' %a)                       # 保留小数点后面六位有效数字:%f
print('保留小数点后面3位小数:%.3f' %a)                    # 保留3位小数位(小数位不够会补0):%.3f
print('保留小数点后面6位小数,以指数形式输出:%e' %a)          # 保留小数点后面六位有效数字，以指数形式输出:%e
print('保留小数点后面3位小数,以科学计数法输出:%.3e' %a)       # 保留3位小数位，以科学计数法:%.3e
# 保证六位有效数字的前提下，使用小数方式输出，否则使用科学计数法输出:%g
print('%g' %a)                                     
print('%g' %(111112.123456))
print('%g' %(0.123456789))
# 保证六位有效数字的前提下，使用小数方式输出，否则使用科学计数法输出:%g
print('%.3g' %a)                               
print('%.3g' %(111112.123456))
print('%.3g' %(0.123456789))

格式化输出

print('{} {}'.format('hello','workld'))                # 不带字段输出
print('{0}{1}'.format('a','123'))                      # 带数字编号【format中的内容下标是以0开始的】
print('{0}{1}{0}'.format('a','1'))                     # 打乱顺序
print('{1}{1}{0}'.format('a','1'))                     # 打乱顺序
print('{a}{b}{b}'.format(a='2',b='c'))                    # 变量名输入

# 情况1，列表顺序不能乱，需要一 一对应
d = ['张三',18,'上海',180]
m = '大家好，我是{}，我今年{}岁了，我来自{}，身高{}cm'.format(*d)   # 单*
print(m)
# 情况2，字典可以打乱顺序，因为是按变量一 一对应的
info ={'name':'李四','age':23,'addr':'北京','height':190}
n = '大家好，我是{name}，我今年{age}岁了，我来自{addr}，身高{height}cm'.format(**info)  # 双*
print(n)

#通过关键字来标识每个变量，显示更清楚: {a} {name} {age}，通过数字编号来表示每个变量，这个序号必须从0开始: {0}  {1}
age = 23
gender = '男'
name = 'Terence'
print("姓名:{0}  性别:{1}  年龄:{2}\n学生姓名:{0}".format(name, gender, age))
print("姓名:{name}  性别:{gender}  年龄:{age}\n学生姓名: {name}".format(name=name,gender=gender,age=age))
print("姓名:{}\n性别:{}\n年龄:{}".format(name, gender, age))

id=input('请输入您的身份证号：')
print('您的出生日期为：{}年{}月{}日'.format(id[6:10],id[10:12],id[12:14]))
print('您的出生日期为：{1}年{0}月{2}日'.format(id[10:12],id[6:10],id[12:14]))
print('您的出生日期为：{year}年{month}月{day}日'.format(month=id[10:12],year=id[6:10],day=id[12:14]))
# 我们分别来理解一下上述3条print语句：
# 第1条：在字符串中我们嵌入了3对“{ }”，并且在format函数的参数中写入了3个参数，程序按照参数从左至右的顺序将字符串进行了格式化;
# 第2条：在字符串中我们仍然嵌入了3对“{ }”，但是每一对“{ }”中都有一个数字，这些数字是从0开始递增的序号,“{0}”表示在该位置要显示从左至右第1个参数的内容， 
# “{1}”表示在该位置要显示从左至右第2个参数的内容，以此类推，所以在输入参数的时候，参数的顺序要与前面的序号相对应。
# 第3条：在字符串中我们也是嵌入了3对“{ }”，这一次每一对“{ }”中都有一个关键字，这些关键字与参数中的关键字相对应，例如，“{month}”表示在该位置要显示关键字参数中“month”后方的值，以此类推；

格式化对齐

print('{} and {}'.format('hello','world'))             # 默认左对齐
print('{:10s} and {:>10s}'.format('hello','world'))    # 取10位左对齐，取10位右对齐
print('{:^10s} and {:^10s}'.format('hello','world'))  # 取10位居中对齐
print('{} is {:.2f}'.format(1.123, 2.234))            # 取2位小数
print('{0} is {0:>10.2f}'.format(1.123))              # 取2位小数，取10位后右对齐
print('--------------------------------------------------------')
name = 'Terence'
print('姓名：{:10}'.format(name))         # 默认左对齐
print('姓名：{:<10}'.format(name))        # 左对齐
print('姓名：{:>10}'.format(name))        # 右对齐
print('姓名：{:^10}'.format(name))        # 中间对其
print('--------------------------------------------------------')
print('小数：{:10.2f}'.format(3.1415926))   # 保留2位有效数字，在10个字符空间中打印，默认右对齐
print('小数：{:>10.2f}'.format(3.1415926))  # 保留2位有效数字，在10个字符空间中打印，右对齐
print('小数：{:<10.2f}'.format(3.1415926))  # 保留2位有效数字，在10个字符空间中打印，左对齐
print('小数：{:^10.2f}'.format(3.1415926))  # 保留2位有效数字，在10个字符空间中打印，中间对其

input( )

用键盘向电脑提供指令，然后通过电脑把问题显示在显示器上，等人回答的过程，就是通过input( )函数实现的

input( )函数就是输入函数，当你在函数的括号内写出问题时，input()函数会将此问题原样显示在屏幕上，并在终端区域等待你针对此问题的回答;
可是，我们为什么要在终端处输入回答呢？不输入行不行？
我们可以把input( )函数看作一扇链接现实世界与代码世界的门，当问题从代码世界传递给我们，可我们却没有回答时，这扇等待输入的input( )大门，就会一直处于敞开状态，一直等着你往里送回答，而当我们输入信息后，这扇input( )大门便会关上，继续执行下面的命令.

input( ) 将结果赋值给变量

input函数的结果是什么？
这里所说的函数结果指的就是我们手动输入到屏幕上的东西.

赋值是如何体现？
name = input(‘内容’)，在这个语句中，我们在屏幕上输入的东西被赋值给了name（输入的内容可以是数字、文字）；
通俗来讲，我们放进name这个盒子里的东西，不是input()函数中提的问题，而是我们通过input()函数收集到的别人的答案；
也就是说把input( )函数的结果，赋值给了一个变量，如果没有赋值的话，整个程序就在你输入后就结束了，不会将你输入的内容反馈给你.

input( ) 的数据类型

Python3.x中,input( )函数接受一个输入的数据, 注意:使用input输入和输出的数据一律为字符串类型, 哪怕输入的是数字;
对于input( ), 它希望能够读取一个合法的python表达式, 即输入字符串的时候必须使用引号将它括起来, 否则它会引发一个 SyntaxError;
使用input( ), 通过在提示的末尾（这里是冒号后面）包含一个空格, 可将提示与用户输入分开, 让用户清楚地知道其输入始于何处;

对于input()函数来说，不管我们输入的回答是什么，不管输入的是整数1234，还是字符串我爱摩卡，input()函数的输入值（搜集到的回答），永远会被强制性地转换为字符串类型（固定规则）;
跟“你大爷还是你大爷，你大妈已经不是你大妈”一个道理：我爱摩卡即使被强制转换，它还是字符串类型的我爱摩卡；但是我们输入的整数1234就会被强制地转换为字符串的’1234’;
所以，不管我们在终端区域输入什么，input()函数的输入值一定是字符串; 就这样，由于我们用赋值运算符=把input()函数的字符串结果，赋给了变量choice，所以这个变量也一定是字符串类型;

input( ) 的数据类型转换

我们什么时候会用到，input()函数结果的强制转换呢？当想要的答案是数字时，比如年龄，需要输入的信息是时间，或者工资等数字时：

input( ) 总结

input( ) 案例

# 输入姓名，性别，并打印（带标准格式化输出）
name = input('请输入姓名:')
gender = int(input('请输入年龄:'))
print('姓名:%s, 年龄:%d' %(name,gender))

# 输入两个数,求两个数之和 (带标准格式化输出)
a = int(input('请输入第一个数:'))
b = int(input('请输入第二个数:'))
print('两数之和为:%d' %(a+b))

# 下面演示一种创建多行字符串的方式 
# 第1行, 将消息的前半部分存储在变量a1中;
# 第2行, 通过运算符+=将存储在a1中的字符串末尾附加一个组字符串；
a1 = 'Tell me your name? '
a1 += 'What your name?'
name1 = input(a1)
print('\nHello,%s' %(name1))

变量

• 程序可以操作的存储空间的名字，程序运行期间可以更改数据，每个变量都有特定的数据类型，使用变量前一定要先对变量赋值（即便是空也行）；
• 定义变量名，变量名 = 初始值（这个初始值的目的就是为了告诉变量名当前使用的是什么数据类型）；
• 定义变量目的是为了存储数据，变量 = 数据值，变量在使用之前必须定义，否则会报错；
• 在给变量起名字的时候，相当于在内存中划出了一块空间，变量名 = 内存空间地址；

命名规则（标识符）

• 见名知意；
• 只能由字母，数字，下划线组成，不能以数字开头，如：可命名为 message_1 ，但不能将其命名为 1_message；
• 区分大小写，如：a和A是两个不同命名；
• 遵循驼峰原则（首单词正常，从第二个单词开始首字母大写，如：sunckGoodMan）；
• 慎用小写字母l和大写字母O, 因为它们可能被人错看成数字1和0；
• 不能包含有空格，如：变量名greeting_message可行，但变量名greeting message会引发错误；
• 不能是python的关键字，如:

定义变量

# 注意：定义了一个变量，如果这个变量使用过（比如打印过一次），那么就算一次完整的周期，所以必须等相同的变量打印过一次之后才能再次使用这个变量名
# 1，定义一个变量
num01 = 11111
print(num01)
# 2，定义多个变量，单独定义（方法1）
num01 = 100
num02 = 200
num03 = 300
print('方法1结果为:' + str(num01)+','+str(num02)+','+str(num03))
# 3，定义多个变量，写在一行，使用分号隔开（方法2）
num01 = 100; num02 = 200; num03 = 300
print('方法2结果为:' + str(num01)+','+str(num02)+','+str(num03))
# 4，定义多个变量，使用交互式赋值（方法3）
num01, num02, num03 = 100, 200, 300       
print('方法3结果为:' + str(num01)+','+str(num02)+','+str(num03))
# 5，定义多个变量（赋值传递，将300赋值给num03，然后num03赋值给02.....不推荐使用）
num01 = num02 = num03 = 300       
print('方法4结果为:' + str(num01)+','+str(num02)+','+str(num03))

变量是如何存储数据

num01 = 100
# 如何获取num01变量的内存地址？
print(id(num01))                  # 输出变量num01存储的内存十进制数值！
num02 = num01
print(id(num02))                  # 结果和num01的内存地址一样

不推荐的变量定义方法

# 不推荐的命名1：使用单个字母来命令，图简单，没有特殊意义，容易混淆
a = 100
b = 200
c = 300
# 不推荐命令2：使用拼音
xsxm = 'abby'
nianling = 26
shengao = 178
# 下面的程序会报错
num01 += 100                     # 等价于num01 = num01 + 100
print(num01)
# 修正(正确)
num01 = 10
num01 += 100                    # 在运用变量时，若涉及到要调用变量本身，一定要提前将变量说明清楚
print(num01)

删除变量

del 变量名

数据类型

整型（没有小数点的数字）

# 整型，最终都会转化成十进制
num01 = 1000              # 十进制
num02 = 0x1F              # 十六进制，逢16进1   1*16 + 15 =32
num03 = 0o31              # 八进制，3*8 +1 =25
print(num01)
print(num02)
print(num03)
print(bin(100))  # 打印二进制

import math  # 通过import将math引入进来
# 常见的数学运算
print(abs(-100))                          #求绝对值
print(math.fabs(-100))                  #求绝对值,带小数点(math属于外部模块)
print(math.sqrt(100))                      #求平方根，10的平方是100
print(math.pow(3, 4))                      #求3的4次方
print('-------------------------------------')
print(max(10, 100, -34, 398, 91))          #返回最大值
print(min(10, 100, -34, 398, 91))          #返回最小值

备注：整数只能单独“行动”，一旦碰上其他文字类数据，譬如中文、英文，整数这个脆皮刺客，立马被报错秒杀，比如像这样：

print(6小灵童)
print(6abc)

浮点数（带小数点的数字）

# 小数只能有17位有效数字，如果能用17位有效数字表示，那么就用小数点表示，如果17位无法表示，就使用科学记数法
print(3.1415926)
print(1111111111.111)
print(11111111111111111.111)
print(0.000000000000000001)
print(333333333333333333333333333.231313131)
# round() ----函数
print(round(3.1415926))                      #取整数
print(round(3.1415926, 3))                  #保留3位小数，并四舍五入
# ceil() ----返回该小数的上入整数(正数，就+1，负数，取当前整数部分，所以是-11)
# floor() ----返回该小数的下舍整数(正数，取当前整数部分，负数，去当前整数部分+1)
print(math.ceil(11.111111))                  #结果：12
print(math.ceil(-11.111111))                  #结果：-11
print(math.floor(11.111111))                  #结果：11
print(math.floor(-11.111111))                  #结果：-12

布尔类型

# 布尔类型：它就是数值类型，可以直接做数学运算(Flase=0,True=1)
print(False + 100)
print(True + 100)
print(True * 2)

总结

#数据类型
num01 = 100
num02 = - 93.7
num03 = (100 > 200)
num04 = 'Abby'
# 使用type直接输出数据类型
num1 = 100
num2 = -28.888
num3 = (100 > 200)
num4 = "Abby"
print("num1的数据类型为:", type(num1))
print("num2的数据类型为:", type(num2))
print("num3的数据类型为:", type(num3))
print("num4的数据类型为:", type(num4))

数据类型转换

示例

# 转换1
a = int('100') + 20
print('a 结果为:-------->',a,'-------->',type(a))
# 转换2
# float()函数可以将【整数】和【字符串】转换成浮点类型，但同时，如果括号里面的数据是【字符串类型】，那这个数据一定得是【数字形式】
b1 = float('1.123') + 1.100
b2 = float('100') 
print('b1 结果为:-------->',b1,'-------->',type(b1))
print('b2 结果为:-------->',b2,'-------->',type(b2))
# 转换3
c = str(123) + '456'
print('c 结果为:-------->',c,'-------->',type(c))
# 转换4
d = bool(-1)
print('d 结果为:-------->',e,'-------->',type(d))
# 转换5
e = bool(0)
print('e 结果为:-------->',e,'-------->',type(e))
# 转换6
# int()函数的本质是将数据转换成整数，所以对于浮点数，int()会做取整处理，但是，同我们平时对小数四舍五入的处理方式不同，int()函数会直接抹零,直接输出整数部分。
f = int(3.1415926)
print('f 结果为:-------->',f,'-------->',type(f))

错误的示例

g = int('3.8')
print(g)

运算符

算术运算符

算数运算符 —-> “+”号，用于数据运算，也可以用于连接字符串，任何数据类型 + 字符串，都等于字符串

赋值运算符

简单的最常用的=运算符,他的优先级别低于其他的运算符，所以对该运算符往往最后读取.

比较(关系)运算符

对两个变量或者值进行比较的运算符,比较的结果是布尔值，即True/False.

# 这里还有一个语法：意思为：将a值与2的比较结果，赋给b，b得到的是一个布尔值。
a= 1
b = a == 2
b

逻辑运算符

成员运算符

身份运算符

按位运算符

运算符优先级

使用各运算符小技巧

# 逻辑运算符运算规则：
## and看做乘法， or看做加法，True看做1， False看做0
## 则逻辑运算就能转换成整数数学运算
## 最后结果如果是0则为False， 否则为True
a = True
b = False
c = True
d = a and b or c         # 该式子等价于 d = 1 * 0 + 1
print(d)
e = a or b and a
print(e)
# 短路语句用法：
2 > 1 and print('lalala')
# 上边是将布尔值当数值来计算，逻辑运算还有一种运算方法，为运算符的原始用法：
a = 1 and 2 + 2
print(a)
# 程序运行逻辑为：先看第一表达式转换成布尔值的结果，如果结果为真，那么它会看第二个表达式转换为布尔值的结果，如果只有两个表达式的话，就只看到第二个表达式，并返回该表达式的值。
# 此处的1 and 2，判断1为真，直接返回2的值，a=2+2=4
# 如果判断第一个表达式为False，直接停止接下来的判断，并返回第一表达式的值，也就是0
# 如果有多个表达式，按此规则，依次往后看。
# p.s: undefined、null、NaN、none、" "、0、false均视为False
# 若果是或运算，和与运算不同，判断第一个表达式为真，就直接返回第一表达式的值，不看后边的了, 第一表达式为假时，才往后看。
2>1 or print('lalala')
# not非运算，就是结果取反
f = 1
f = not f
print(f)

转义字符

• 带有转义字符的情况下；
• 或在字符串前加 ‘r’ (取消转义字符) ```python

  输出打印带有特殊符号的字符串，如：将’D:\abc\av.avi’，包括引号在内一起打印出来

  print(“\’D:\abc\av.avi\’”) print(“D:\abc\\nav,avi\n”)

print(‘D:\new’) #本来想打印“new”这个单词，结果被\n换行了 print(‘D:\new’) #再加入一个“\”,比如下面的例子
print(‘D:\new_project\test\nt\files\data’) #如果想正常使用这个路径，我们需要加上多个“\”，很麻烦

取消转移功能

print(r”D:\abc\av.avi”) print(r’D:\new_project\test\nt\files\data’) #是在字符串之前写一个“r”，将它转换为原始字符串 print(r’D:\new_project\test\nt\files\data’’\‘) #以“\”结尾，需要对末尾的“\”单独进行转义，并和前面的字符串连接 print(R”D:\abc\av.avi”) ```