Python Day 3

　　阅读目录：

　　　　　内容回顾：

　　　　　变量（标识符）的命名规范：

　　　　　常量：

　　　　　格式化输入\输出：

　　　　　注释：

　　　　　基本数据类型：

　　　　　运算符：

　　

　　##内容回顾　　　　　

　　　　　　

           1.语言的分类：
　　　　　　　-- 机器语言：直接编写0,1指令，直接能被硬件执行。
　　　　　　　-- 汇编语言：编写助记符（与指令的对应关系），找到对应的指令直接交给硬件执行。
 　　　　　　 -- 高级语言：编写人能识别的字符，要通过编译器或解释器转换为汇编语言最终转换为机器语言的指令交给硬件执行。
　　　　　　　　运行效率最高：机器语言
　　　　　　　开发效率最高：高级语言
 　　　　　　　　维护成本：控制维护成本、例：小米手机 组装机，没有开发团队，没自身的技术硬实力。
 　　　　　　2.计算机组成：控制器 + 运算器 + 存储器 + 输入input设备 + 输出output设备
 　　　　　　3.三大核心：cpu + 内存 + 硬盘
 　　　　　　4.环境的搭建：环境变量：python解释器 | pip install 工具
 　　　　　　5.两种执行方式: 交互式 | 脚本式
 　　　　　　6.变量：
 　　　　　　　 -- 声明： 变量名 = 变量值
　　　　　　　　-- 变量值：变量名  类型：type(变量名)  地址：id(变量名)
 　　　　　　　 -- == | is: == 值比较 | is地址比较
 　　　　　　　 -- 1111111111111111111111111111111111111111
　　　　　　7.pycharm安装于创建项目
　

　　##变量（标识符）的命名规范：　　　　　

　　　　　　#1.只能由 字母 数字 及 _ 组成
　　　　　　#2.不能以数字开头
　　　　　　#3.避免与系统关键字重名：重名不会报错，但系统的功能就被自定义的功能屏蔽掉了（严重不建议这样来做）
注：以下关键字变为变量名直接回出现错误。

　　　　　　　　

　　　　　　

　　　　　　#4.以_开头的变量都有特殊含义
　　　　　　#5.以__开头与结尾的叫魔法变量：内置变量
　　　　　　#6.建议使用_连接语法来声明长变量名：owen_name old_boy_edu
　　　　　　#7.支持小驼峰与大驼峰命名规范：owenName | OwenName
　　　　　　#8.多个单词的简写建议使用全大写：URL | HTTP | HTML
　　　　　　#9.用全大写来标识常量：PI = 3.141592653 | OWEN_SALARY = 88888

　　

　　##常量：　　　　

　　　　python中没有严格的常量语法：
 　　　　　-- 常量：在程序运行过程中，值不能被改变的量
　　　　　 -- python中所有的量在运行过程中其实都能发生改变，只能自我保障不去改变全大写定义的变量值
 

　　##格式化输入\输出：　　

　　　　1.输出：自带换行　
　　　　　　　　　　py2
　　　　　　　　　　　　print(10)
　　　　　　　　　　　　print 10 : py3被遗弃
　　　　　　　　　　py3
　　　　　　　　　　　　print(10)
　　　　2.输入：
　　　　　　　　　　py2
　　　　　　　　　　　　info = input('提示信息：')
　　　　　　　　　　　　# 细节
　　　　　　　　　　　　# 1.可以输入一个值，但一定要按照值得表示方式进行输入，10就是数字 'abc'就是字符串
　　　　　　　　　　　　# 2.如果输入的是abc，默认将abc作为变量来解读，如果变量abc未定义就报错

　　　　　　　　　　　　#raw_input(): 采用所有输入都以字符串进行存储
　　　　　　　　　　py3
　　　　　　　　　　　　info = input('提示信息：')
　　　　　　　　　　　　# 细节
　　　　　　　　　　　　# 1.所有信息都是直接输入，都会被转换为字符串存储 == raw_input

 

　　##注释：　　　　　　　　

　　　　注释：不会被python解释器解释执行，是提供给开发者阅读代码的提示
　　　　　　单行注释： # 开头的语句
　　　　　　多行注释：出现在文件最上方，用''''''包裹的语句
　　　　　　pycharm快捷键：
　　　　　　　　　　ctrl + /　　注释
　　　　　　　　　　ctrl+Alt+l    整理代码

　　　　

　　##基本数据类型：

　　　　　　1.整型　　　　

　```````# py2下：数据过长用long类型存储 | 数据量小的整型用int存储
　```````# py3下：long被遗弃 | 所有整型都用int存储（优化：数据量过大，采用字符串存储处理，如果需要运算，可以直接拿来运算）

　　　　　　　　2.浮点型　　　　　　　　　

`````````# float: 用来存放小数
　```````` salary = 88888.0123456789
​`````````# 可以通过格式化方式来绝对输出格式
`````````# %.6f % salary
`````````# 1）%f对浮点型数据进行占位
`````````# 2）.后的数据数字表示小数精度
`````````# 3）.前的数据是输出的长度，小于等于要输出的数据长度不起作用，超出就采用规定的最大长度
`````````# 注：%015.6f：右对齐，左侧不足拿0填充， %-15.6f: 左对齐输出
　　　       print('%015.6f' % salary)
`````````# 了了解
`````````# 可以将格式化的结果进行保存，以便之后再次使用
　　　      info = '%015.6f' % salary
　　　      print(info)

　　　　　　　3.布尔类型　　　　　　　　

　　　　　# bool类型：就是两个值 True | False
　　　　　　result = False
　　　　　　print(result)

　　　　　　　　4.字符串类型　　　　　　　

　　　　　# 单行字符串： "" | ''
　　　　　# 多行字符串： """""" | ''''''
​
　　　　　# 案例：
　　　　　　　　　name = input('name: ')
　　　　　　　　  age = input('age: ')

　　　　　# %s是万能占位符, %是用来连接有占位符的字符串与需要占位的变量，多个变量用()包裹
　　　　　　　　　info = """信息:
　　　　　　　　　name: %s
　　　　　　　　　age: %s""" % (name, age)
　　　　　　　　　print(info)

　　　　　　　　5.列表　　　　　　

　　　　　# 1、定义：变量名 = [多个值，之间用,隔开]
　　　　　　　　　ls = [3, 1, 2]
​
　　　　　# 2、列表变量名ls访问的是列表整体
　　　　　　　　　print(ls)  # [3, 1, 2]
​
　　　　　# 3、通过索引(index)来访问具体的值，index从0开始编号： ls[index]
　　　　　　　　 print(ls[0])  #
​
　　　　　# 4、ls的嵌套及值的访问
　　　　　　　　 ls = [[1, 2, 3], [4, 5, 6], [7, 8, [9]]]

　　　　　# 访问数字9
　　　　　　　　 print(ls[2][2][0])
​
　　　　　# 重点：list存放值的方式： eg：[3, 1, 2] => 列表的0号位存放的不是数字3，而是堆区3空间的地址 (如下图)

　　　　　　　　　　6.字典　　　　　　　

　　　　　　# 列表能存放多个值，但多个值只能通过index区分，但是index没有语义
　　　　　　# 需找即可以存放多个值，切每个值有一个语义描述 => dict类型
　　　　　　# 定义：{}是用来定义字典的语法，key是用来描述最终要访问的value值的，key对于开发者来说是已知的
　　　　　　# 访问：通过 dic[key]来访问key描述的值
　　　　　　　　　　　　　　　　　　dic = {'key': 'value'}
　　　　　　　　　　　　　　　　　　'''
　　　　　　　　　　　　　　　　　　people = {
   　　　　　　　　　　　　　　　　　　　　　　'name': 'Liuxx',
   　　　　　　　　　　　　　　　　　　　　　　'age': 68,
   　　　　　　　　　　　　　　　　　　　　　　'gender': '哇塞'
　　　　　　　　　　　　　　　　　　　　　　　　}
　　　　　　# 整体访问
　　　　　　　　　　　　　　　　　　print(people)
　　　　　　# 访问年龄的值，[将key原样拿下来] => ['age']
　　　　　　　　　　　　　　　　　　print(people['age'])
​
　　　　　　# 案例
　　　　　　# 字典的嵌套
　　　　　　　　　　　　　　　　　　info = {
   　　　　　　　　　　　　　　　　　　　　'name': 'egon',
   　　　　　　　　　　　　　　　　　　　　'hobbies': ['play', 'sleep'],
   　　　　　　　　　　　　　　　　　　　　'company_info': {
       　　　　　　　　　　　　　　　　　　'name': 'Oldboy',
       　　　　　　　　　　　　　　　　　　'type': 'education',
       　　　　　　　　　　　　　　　　　　'emp_num': 40,
  　　　　　　　　　　　　　　　　　　　　　　 }
　　　　　　　　　　　　　　　　　　　　　　　}
　　　　　　# 拿到40 | 拿到 'sleep'
　　　　　　　　　　　　　　　　　　　res = info['company_info']['emp_num']
　　　　　　　　　　　　　　　　　　　print(res)
　　　　　　　　　　　　　　　　　　　res = info['hobbies'][1]
　　　　　　　　　　　　　　　　　　　print(res)
​
​
　　　　　　　　　　　　　　　　　　　students=[
  　　　　　　　　　　　　　　　　　　　　　　{'name':'alex','age':38,'hobbies':['play','sleep']},
  　　　　　　　　　　　　　　　　　　　　　　{'name':'egon','age':18,'hobbies':['read','sleep']},
  　　　　　　　　　　　　　　　　　　　　　　{'name':'wupeiqi','age':58,'hobbies':['music','read','sleep']},
　　　　　　　　　　　　　　　　　　　　　　　　]
　　　　　　# 第二个学生的第一个爱好
　　　　　　　　　　　　　　　　　　print(students[1]['hobbies'][0])

　　##运算符：

　　　　　　　　　

　　　　　　1.算术运算符
　　　　　　　　　　# + | - | * | / | // | ** | %
　　　　　　　　　　# 1.字符串和list可以做 + 和 *
　　　　　　　　　　# 2./非整除，// 为整除
　　　　　　　　　　# 3.**求幂：5 ** 2 => 25
　　　　　　　　　　# 4.任意数 % n => [0, n-1]
　　　　　　　　　　# 5.有负数参与的取余：符号跟着 % 后面那个数
　　　　　　2.比较运算符
　　　　　　　　　　# > | < | == | != | >= | <=
　　　　　　　　　　# 1.运算结果为bool类型
　　　　　　　　　　　　print(3 > 5)
　　　　　　　　　　# 2.可以连比
　　　　　　　　　　　　num = 10
　　　　　　　　　　　　print(1 < num < 20)

　　　　　　3.赋值运算符　　　
　　　　　　　　　　# += | -= | *= | /= | %= | **= | //= | =
　　　　　　　　　　　　num = 10
　　　　　　　　　　　　num += 1  # num = num + 1 => 11

　　　　　　　　　　# 1.链式赋值
　　　　　　　　　　　　a = b = num

　　　　　　　　　　# 2.交叉赋值
　　　　　　　　　　　　x = 10
　　　　　　　　　　　　y = 20
　　　　　　　　　　　　x, y = y, x

　　　　　　　　　　# 3.解压赋值
　　　　　　　　　　　　ls = [3, 1, 2]
　　　　　　　　　　　　a, b, c = ls

　　　　　　　　　　# _是合法的变量名，会接受值，但我们认为_代表该解压位不用接收，用_来接收表示
　　　　　　　　　　　　_, _, g = ls  # g才存放2，其他标示不接受

　　　　　　4.逻辑运算符
　　　　　　　　　　
　　　　　　　　　　# and  |  or  |  not
　　　　　　　　　　# 1.and: 左右都成立才成立，有不成立的就不成立
　　　　　　　　　　# 2.or: 左右都不成立才不成立，有成立的就成立
　　　　　　　　　　# 3.ont: 成立则不成立，不成立则成立
　　　　　　　　　　#重点：
　　　　　　　　　　　　　　res = 0 and 20  # and前为假，整个式子就可以确定为假了，and后就不需要执行(短路)
　　　　　　　　　　　　　　print(res)  #
　　　　　　　　　　　　　　res = 10 or 20  # or前为真，整个式子就可以确定为真了，or后就不需要执行(短路)
　　　　　　　　　　　　　　print(res)  #