- 用户与程序交互
- 数据类型(简单介绍)
- 基本运算符
-曾老湿, 江湖人称曾老大。
-多年互联网运维工作经验，曾负责过大规模集群架构自动化运维管理工作。 -擅长Web集群架构与自动化运维，曾负责国内某大型金融公司运维工作。 -devops项目经理兼DBA。 -开发过一套自动化运维平台（功能如下）： 1)整合了各个公有云API，自主创建云主机。 2)ELK自动化收集日志功能。 3)Saltstack自动化运维统一配置管理工具。 4)Git、Jenkins自动化代码上线及自动化测试平台。 5)堡垒机，连接Linux、Windows平台及日志审计。 6)SQL执行及审批流程。 7)慢查询日志分析web界面。
用户与程序交互
古时候，我们去银行取钱，需要有一个银行业务员等着我们把自己的账号密码输入给他，然后他去进行验证，成功后，我们再将取款金额输入/告诉他
骄傲的现代人，会为客户提供一台ATM机（就是一台计算机），让ATM机跟用户交互，从而取代人力。然而机器是死的，我们必须为其编写程序来运行，这就要求我们的编程语言中能够有一种能与用户交互，接收用户输入数据的机制
什么是与用户交互 |
|---|
程序等待用户输入一些数据，然后程序执行完毕后为用户反馈信息。
为什么要与用户交互 |
|---|
为了让计算机能够像人一样，可以和用户交流，识别用户提供的信息。
input的区别 |
|---|
#在python3中
input：用户输入任何值，都存成字符串类型
#在python2中
input：用户输入什么类型，就存成什么类型
raw_input：等于python3的input如何使用与用户交互 |
|---|
在Python中input和SHELL中的 read用法相同，只不过不需要写上很多选项。
#接收用户输入的用户名
username=input('please input your username:')
#接收用户输入的密码
pwd=input('please input your password:')
#打印出 用户名和密码
print(username,pwd)

注释 |
|---|
随着学习的深入，用不了多久，你就可以写复杂的上千甚至上万行的代码啦，有些代码你花了很久写出来，过了些天再回去看，发现竟然看不懂了，这太正常了。 另外，你以后在工作中会发现，一个项目多是由几个甚至几十个开发人员一起做，你要调用别人写的代码，别人也要用你的，如果代码不加注释，你自己都看不懂，更别说别人了，这产会挨打的。所以为了避免这种尴尬的事情发生，一定要增加你代码的可读性。
代码注释分单行和多行注释， 单行注释用#，多行注释可以用三对双引号""" """
代码注释的原则：
代码语言：javascript复制#1. 不用全部加注释，只需要在自己觉得重要或不好理解的部分加注释即可
#2. 注释可以用中文或英文，但不要用拼音文件头
代码语言：javascript复制#!/usr/bin/env python
# -*- coding: utf-8 -*- 格式化输出 |
|---|
程序中经常会有这样场景：要求用户输入信息，然后打印成固定的格式
比如要求用户输入用户名和年龄，然后打印如下格式：
My name is zls，I'm 18 years old.
很明显，用逗号进行字符串拼接，只能把用户输入的名字和年龄放到末尾，无法放到指定的xxx位置，而且数字也必须经过str(数字)的转换才能与字符串进行拼接。
这就用到了占位符，如：%s、%d
代码语言：javascript复制#%s字符串占位符：可以接收字符串，也可接收数字
print('My name is %s,my age is %s' %('zls',18))
#%d数字占位符：只能接收数字
print('My name is %s,my age is %d' %('zls',18))
print('My name is %s,my age is %d' %('zls','18')) #报错
#接收用户输入，打印成指定格式
name=input('your name: ')
age=input('your age: ') #用户输入18,会存成字符串18,无法传给%d
print('My name is %s,my age is %s' %(name,age))
#注意：
#print('My name is %s,my age is %d' %(name,age)) #age为字符串类型,无法传给%d,所以会报错练习：用户输入姓名、年龄、工作、爱好 ，然后打印成以下格式
代码语言：javascript复制------------ info of zls -----------
Name : zls
Age : 18
Sex : male
Job : Teacher
------------- end -----------------数据类型(简单介绍)
什么是数据？为何要有多种类型的数据？
1.数据即变量的值，如age=18，18则是我们保存的数据。 2.变量的是用来反映/保持状态以及状态变化的，毫无疑问针对不同的状态就应该用不同类型的数据去标识
数字 |
|---|
1.int整型
作用：记录年龄，等级，QQ号，各种号码 定义：age=10 #age=int(10)
代码语言：javascript复制age=18
print(age,type(age))
#结果
18 <class 'int'>

2.float浮点型 作用：记录工资，身高，体重 定义：salary=3.1 #salary=float(3.1)
代码语言：javascript复制salary=3.1 #salary=float(3.1)
print(salary,type(salary))
#结果
3.1 <class 'float'>

其他数据类型了解
代码语言：javascript复制#int（整型）
在32位机器上，整数的位数为32位，取值范围为-2**31～2**31-1，即-2147483648～2147483647
在64位系统上，整数的位数为64位，取值范围为-2**63～2**63-1，即-9223372036854775808～9223372036854775807
#long（长整型）
跟C语言不同，Python的长整数没有指定位宽，即：Python没有限制长整数数值的大小，但实际上由于机器内存有限，我们使用的长整数数值不可能无限大。
注意，自从Python2.2起，如果整数发生溢出，Python会自动将整数数据转换为长整数，所以如今在长整数数据后面不加字母L也不会导致严重后果了。
注意：在Python3里不再有long类型了，全都是int
>>> a= 2**64
>>> type(a) #type()是查看数据类型的方法
<type 'long'>
>>> b = 2**60
>>> type(b)
<type 'int'>
#complex复数型
>>> x=1-2j
>>> x.imag
-2.0
>>> x.real
1.0
其他数据类型（了解部分）字符串类型 |
|---|
字符类型：str
作用：描述性的内容，如姓名，性别，国籍，种族
定义：在引号内，包含一系列字符，引号可以是：单引号，双引号，三引号
在python中，加了引号的字符就是字符串类型，python并没有字符类型。
name='zls'
print(name,type(name))
name1="zls"
print(name1,type(name1))
name2='''zls'''
print(name2,type(name2))
name3="""zls"""
print(name3,type(name3))
#结果
zls <class 'str'>
zls <class 'str'>
zls <class 'str'>
zls <class 'str'>

三引号，一般在多行数据使用，例如：
代码语言：javascript复制info='''
name:zls
age:18
job:teacher
'''
print(info)
#结果
name:zls
age:18
job:teacher

引号的嵌套：
如果说，我有一个需求，我想要给人名加上引号打印出来
My Name Is 'zls'.
错误写法：
代码语言：javascript复制name='My Name Is 'zls'.'
print(name)

正确写法：
代码语言：javascript复制name="My Name Is 'zls'."
print(name)
#结果
My Name Is 'zls'.

一定要搞清楚，引号的配对。
Python中独特用法：字符串运算
1.字符串相加（字符串拼接）
字符串只能与字符串相加，但是效率不高
代码语言：javascript复制message1='hello'
message2='world'
print(message1 message2)
#结果
helloworld

内存变化

2.字符串相乘
字符串之间可以相乘，做乘法运算，但是不是字符串与字符串相乘，是字符串与数字相乘。
代码语言：javascript复制print('hello'*10)
print('华丽的分割线' '-'*100)
#结果
hellohellohellohellohellohellohellohellohellohello
华丽的分割线----------------------------------------------------------------------------------------------------

列表类型 |
|---|
如果定义一个人的爱好，使用字符串类型，爱好是多种多样的，例如：
代码语言：javascript复制hobbies='eat music sleep play'如何取出第三个爱好？
列表类型：list
作用：记录/存放多个值，可以方便的出去来指定位置的值，比如，人的多个爱好，一堆学生的姓名。
定义：在[]内用逗号分隔开，多个任意类型的值。
例如： list=[1,3.1,'zls',['a','b']]
列表类型如何取值？
代码语言：javascript复制list=[1,3.1,'zls',['a','b']]
print(list)
#结果
[1, 3.1, 'zls', ['a', 'b']]

代码语言：javascript复制list=[1,3.1,'zls',['a','b']]
print(list[0])
print(list[1])
print(list[2])
print(list[3])
print(list[3][0])
print(list[3][1])
#结果
1
3.1
zls
['a', 'b']
a
b

小练习
代码语言：javascript复制#请取在下面列表中，取出bgx的爱好？
student_info=[['zls',18,'play'],['egon',19,'beautiful girl'],['bgx',20,'play beautiful girl']]
#取出下面列表中的j
list=['a','b',['c','d',['e',['f',['g',['h','i','j']]]]]]字典类型 |
|---|
为何还要用字典？
代码语言：javascript复制info=['zls',18,'male',['oldboy',200,'SH']]
如何取出，性别和所在公司名称？
info=['zls',18,'male',['oldboy',200,'SH']]
print(info[2])
print(info[3][0])
#存放一个人的信息：姓名，性别，年龄，很明显是多个值，既然是存多个值，我们完全可以基于刚刚学习的列表去存放，如下:
>>> info=['zls','male',18]
#定义列表的目的不单单是为了存，还要考虑取值，如果我想取出这个人的年龄，可以用
>>> info[2]
#但这是基于我们已经知道在第3个位置存放的是年龄的前提下，我们才知道索引2对应的是年龄
#即： name, sex, age
info=['zls','male',18]
#而这完全只是一种假设，并没有真正意义上规定第三个位置存放的是年龄，于是我们需要寻求一种，即可以存放多个任意类型的值，又可以硬性规定值的映射关系的类型，比如key=value，这就用到了字典字典类型作用：
记录多个key:value值，优势是每一个值value都有其对应关系/映射关系key，而key对value有描述性的功能。可以更为方便高效地取值。
字典类型定义：
在{}内用逗号分隔开多个key:value元素，其中value可以死任意的数据类型，而key通常应该是字符串类型。
info={'name':'zls','sex':'male','age':18} #info=dict({'name':'zls','age':18,'sex':'male'})
print(type(info))如何取值？
代码语言：javascript复制info={'name':'zls','sex':'male','age':18}
print(info['name'])
print(info['sex'])
print(info['age'])
#结果
zls
male
18

字典嵌套取值：
代码语言：javascript复制#取出下列字典的公司名
info={
'name':'zls',
'hobbies':['play','eat'],
'company_info':{
'name':'Oldboy',
'type':'education',
'emp_num':40,
}
}
print(info['company_info']['name'])注意：在python中，字典是无序的，python2中可以明显看出，但是python3中有算法的优化，所以看起来像是有序的。
小练习
代码语言：javascript复制#取出oldboy的第二个爱好
students=[
{'name':'zls','age':18,'hobbies':['play','sleep']},
{'name':'oldboy','age':40,'hobbies':['read','sleep']},
{'name':'bgx','age':58,'hobbies':['music','read','sleep']},
]什么时候选择列表，什么时候选择字典？
列表：当你存的多个数据，是同一种类，或者同一种性质的，例如：所有人的名字。 字典：当你存的多个数据，非同一种类，或者非同种性质的，例如：多个人的信息，名字、年龄，身高。
布尔类型 |
|---|
布尔类型：bool
作用：用来作为判断条件去用
1.布尔值，一个True一个False 2.计算机俗称电脑，即我们编写程序让计算机运行时，应该是让计算机无限接近人脑，或者说人脑能干什么，计算机就应该能干什么，人脑的主要作用是数据运行与逻辑运算，此处的布尔类型就模拟人的逻辑运行，即判断一个条件成立时，用True标识，不成立则用False标识
定义：
代码语言：javascript复制tag=True # tag=bool(True)
tag1=False
print(type(tag))
print(type(tag1))
#结果
<class 'bool'>
<class 'bool'>age=18
print(age>20)
print(age>=20)
print(age>=20)
print(age==20)
#结果
False
False
False
Trueis 和 == 的区别
代码语言：javascript复制x=100
y=100
print(x==y)
print(x is y)
#结果
True
True

但是，如果是在python解释器当中，那么结果如下
代码语言：javascript复制MacBook-Pro:~ driverzeng$ python3
Python 3.6.4 (v3.6.4:d48ecebad5, Dec 18 2017, 21:07:28)
[GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> x=257
>>> y=257
>>> x == y
True
>>> x is y
False
>>> n=256
>>> m=256
>>>
>>> x == y
True
>>> x is y
False

结论:
- 1.== 比较的是值是否相等
- 2.is 比较的是内存中的id是否相等
- 3.重点：只要id相等，那么值一定相等。id不相等，值仍然可以相等。
tag=True
print(id(tag))
res=3>1
print(id(res))
res1=1<10
print(id(res1))
#结果
4304560512
4304560512
4304560512

布尔值可以用来做判断。
基本运算符
算数运算符 |
|---|
计算机可以进行的运算有很多种，可不只加减乘除这么简单，运算按种类可分为算数运算、比较运算、逻辑运算、赋值运算、成员运算、身份运算、位运算，今天我们暂只学习算数运算、比较运算、逻辑运算、赋值运算。
以下假设变量：a=10，b=20
运算符 | 描述 | 实例 |
|---|---|---|
| 加 - 两个对象相加 | a b 输出结果 30 |
- | 减 - 得到负数或是一个数减去另一个数 | a - b 输出结果 -10 |
* | 乘 - 两个数相乘或是返回一个被重复若干次的字符串 | a * b 输出结果 200 |
/ | 除 - 我还能说啥，就是一个数除以另外一个数 | b / a 输出结果 2 |
% | 取模 - 返回除法的余数 | b % a 输出结果 0 |
** | 幂 - 这里指的不是杨幂，是几次方 | a ** b 输出结果 10000000000000000000000000000 |
// | 取整除 - 返回商数的整数部分 | 9//2 输出结果 4 |
print(1 3)
4
print(3-2)
1
print(10 / 3)
3.3333333333333335
print(10 // 3)
3
print(10 % 3)
1
print(2 ** 3)
8比较运算符 |
|---|
以下假设变量：a=10，b=20
运算符 | 描述 | 实例 |
|---|---|---|
== | 等于 - 比较两个对象是否相等 | (a == b) 返回 False |
!= | 不等于 - 比较两个对象是否不相等 | (a != b) 返回 True |
> | 大于 - 比较一个对象是否比另一个对象大 | (a > b) 返回 False |
< | 小于 - 比较一个对象是否比另一个对象小 | (a < b) 返回 True |
>= | 大于等于 - 比较一个对象是否比另一个对象大或者相等 | (a >= b) 返回 False |
<= | 小于等于 - 比较一个对象是否比另一个对象小或者相等 | (a <= b) 返回 True |
a=10
b=20
print(a == b)
False
print(a != b)
True
print(a > b)
False
print(a < b)
True
print(a >= b)
False
print(a <= b)
True了解知识点
代码语言：javascript复制#众所周知，整型之间是可以比大小的，整型和浮点型之间也是可以比大小的
print(10 > 3)
print(10 > 3.1)
#那么字符串之间可以比大小么？
msg1='hello'
msg2='z'
print(msg1 > msg2)
msg1='a'
msg2='Z'
print(msg1 > msg2)
#字符串只能与字符串比较大（安装对应位置的字符参考ASCII表去比较）
常用方式：
msg1='hello'
msg2='Z'
print(len(msg1)>3)
#列表之间可以比较大小么？
l1=[1,2,3]
l2=[10,1]
print(l1 > l2)
#列表只能与列表比较大小（按照对应位置的值依次比较，对应位置的值必须是相同的类型）赋值运算符 |
|---|
以下假设变量：a=10，b=20
运算符 | 描述 | 实例 |
|---|---|---|
= | 简单的赋值运算符 | c=a b 将a b的结果赋值给c |
= | 加法赋值运算符 | c =a 视为 c=c a |
-= | 减法赋值运算符 | c-=a 视为 c=c-a |
*= | 乘法赋值运算符 | c=a 视为 c=ca |
/= | 除法赋值运算符 | c/=a 视为 c=c/a |
%= | 取模赋值运算符 | c%=a 视为 c=c%a |
**= | 幂赋值运算符 | c**=a 视为 c=c**a |
//= | 取余赋值运算符 | c//=a 视为 c=c//a |
age=18
#增量赋值
age=age 1
print(age)
age =1
print(age)
#链式赋值
x=100
y=x
z=y
print(id(x),id(y),id(z))
x=y=z=100
print(id(x),id(y),id(z))
#交叉赋值
m=1000
n=2000
m=n #????
#交叉赋值
m=1000
n=2000
temp=m
m=n
n=temp
print(m,n) #????
#交叉赋值
m=1000
n=2000
m,n=n,m
print(m,n)
#解压赋值
salaries=[11,22,33,44,55,66,77]
#需求，将列表中每一个值赋值给单独一个变量
mon1=salaries[0]
mon2=salaries[1]
mon3=salaries[2]
mon4=salaries[3]
mon5=salaries[4]
mon6=salaries[5]
mon7=salaries[6]
print(mon1,mon2,mon3,mon4,mon5,mon6,mon7)
mon1,mon2,mon3,mon4,mon5,mon6,mon7=salaries
print(mon1,mon2,mon3,mon4,mon5,mon6,mon7)
#需求，我只想要前两个月的工资
mon1,mon2,a,b,c,d,e=salaries
print(mon1,mon2)
mon1,mon2,a,a,a,a,a=salaries
print(mon1,mon2)
mon1,mon2,_,_,_,_,_=salaries
print(mon1,mon2)
#需求我只想要，第一个月和最后一个月的工资
first=salaries[0]
last=salaries[6]
print(first)
print(last)
#合并一行
first,_,_,_,_,_,last=salaries
print(first)
print(last)
#简写
first,*_,last=salaries
print(first)
print(last)一个下划线的含义：一般来说，没有人会用下划线做变量名，所以我们可以让它来充当占位符。
逻辑运算符 |
|---|
运算符 | 描述 | 实例 |
|---|---|---|
and | 布尔 "与" - 如果x为False，x and y返回False，否则它返回y计算值 | (a and b) 返回True |
or | 布尔 "或" - 如果x是True，它返回True，否则他返回y的计算值 | (a or b) 返回 True |
not | 布尔 "非" - 如果x为True，返回False，它返回True | not (a and b)返回False |
#三者的优先级从高到低分别是：not，or，and
>>> 3>4 and 4>3 or 1==3 and 'x' == 'x' or 3 >3
False
#最好使用括号来区别优先级，其实意义与上面的一样
>>> (3>4 and 4>3) or ((1==3 and 'x' == 'x') or 3 >3)
False 
