从python入门到人生巅峰

最新推荐文章于 2024-06-13 23:55:30 发布

「已注销」

最新推荐文章于 2024-06-13 23:55:30 发布

阅读量280

点赞数 1

文章标签： python

本文链接：https://blog.csdn.net/weixin_45535524/article/details/107097019

版权

一、python是一门编程语言

1.1编程语言

本质就是一门语言，是用来人与计算机沟通。

1.2编程

就是把做事的步骤/业务逻辑给翻译下来

1.3程序

存放有代码的文件就是程序或叫软件。

（ps:硬件以外的都是软件。操作文件即操作硬盘→文件是操作系统提供给应用程序/用户操作硬盘的一种功能。所以以后写程序只要写文件即可。）

软件是程序不是进程，进程是程序的一次执行。进程是动态的，而程序是静态的。1个程序可以对应多个进程，但1个进程只能对应1个程序。进程和程序的关系犹如演出和剧本的关系。

1.3.1程序的区分

计算机硬件是死的，计算机硬件的运行都受软件控制，所以说，软件相当于计算机的灵魂

开发程序本质是在控制硬件

具体来说软件分为两种：

1、应用软件：应用程序相关逻辑

2、系统软件：控制底层硬件的

二、计算机基础

1.计算机的五大组成*****

控制器是计算机的指挥系统，负责控制计算机所有其他组件如何工作的

运算器：包括数学运算与逻辑运算

控制器+运算器=》cpu （负责取指令并且运行，一出产是有指令集的）===》人类的大脑

cpu详解

cpu具有向下兼容性

64的cpu既能运行32位的程序也能运行64位的程序

cpu的两种工作状态

1、内核态：运行的程序是操作系统，可以操作计算机硬件

2、用户态：运行的程序是应用程序，不能操作计算机硬件，可以运行指令

内核态与用户态的转换

应用程序的运行必然涉及到计算机硬件的操作，那就必须有用户态切换到内核态下才能实现，所以计算机工作时在频繁发生内核态与用户态的转换

多线程与多核芯片

2****核4线程：

2核代表有两个cpu，4线程指的是每个cpu都有两个线程=》假4核

4****核8线程

4核代表有4个cpu，8线程指的是每个cpu都有两个线程=》假8核

存储器（也可称作IO设备：是输入或输出设备，包括两大部分：设备控制器和设备本身）

作用：是计算机的记忆功能，负责数据的存取

RAM（随机存取存储器/主存）主要用于临时存储数据。断电即丢失

**ROM:**充当只读存储器，断电内容不会丢失，无法改变或删除。存放BIOS基本输入输出操作系统，因ROM不可更改，硬盘可更改，内存会丢失。（一开机，先启动BIOS系统，因cpu会优先从ROM读取数据

CMOS:充当硬盘作用，断电数据丢失，耗电极低。（即使计算机没有加电，时间也仍然可以正确地更新）

分类：

内存（基于电工作）：存取数据快，断电数据丢失，只能临时存取数据。（存储的是高低电频，即二进制，01000101）

内存溢出存在虚拟内存

外存（硬盘，基于磁工作）：存取速度慢，断电数据也不丢，可以永久保存数据.

机械硬盘慢在找东西即平均寻道时间、平均延迟时间，不是传输数据

输入设备input（数据最先存入内存）：如键盘、鼠标

输出设备output：如显示器、打印机

1.1基本工作流程/程序的运行与三大核心硬件（cpu、内存、硬盘）关系：

输入单元→主存储器→CPU→主存储器→输出单元

（cpu从内存取指令→解码→存入内存）

编写的程序一定是要运行于计算机硬件之上， 程序最先是存放于硬盘中的，程序的运行是先从硬盘把（操作系统）代码加载到内存中，然后cpu是从内存中读取指令到应用程序。

ps：程序运行过程中产生的数据最先都是存放于内存

1.2.IO问题与程序的效率

1、把指令依赖的数据事先加载到内存，能从内存取数据就不要从硬盘（output）

2、针对要永久存放到硬盘中的数据，应该在内存中攒一大波后再一次性写入硬盘(input)

2.计算机系统三层结构！

用户/应用程序（暴风影音、腾讯qq、快播、哇嘎）

**操作系统：**是一个软件，连接计算机的硬件与应用软件之间的一个控制程序（windows、linux）

计算机硬件

作用：

1、控制计算机硬件的基本运行

2、把使用硬件的复杂操作封装成简单的功能，给上层的应用程序使用（如：文件就是操作系统提供给应用程序/用户操作硬盘的一种功能。所以写程序只要写文件即可）

3.平台

计算机硬件 + 操作系统 == 平台

软件的跨平台性指的是：一款软件可以在任意平台上运行，是衡量软件质量高低的一个非常重要的指标

二、python介绍

1.python的历史

Python崇尚优美、清晰、简单，

python2x，python3x源码区别：

python2x:

C，java，大牛：重复代码多，冗余，代码不规范。

python3x: 源码规范，清晰，简单。

2.python的编程语言分类、优缺点（重点）

#机器语言：用计算机能听懂的语言，那就是直接用二进制编程，直接操作硬件；
优点：最底层，执行速度最快
缺点：难记，实现一个简单功能需要很多步才能完成，开发效率最低
#汇编语言：简写的英文标识符取代二进制去编写程序，本质仍然是直接操作硬件；
优点：1、运行效率高，但低于机器语言。2、解决机器语言二进制难记问题。
缺点：开发效率低
#高级语言：人类能理解的表达方式去编写程序，计算机无法直接理解，需要翻译成二进制后才能被执行，屏蔽了硬件操作
1）编译型语言执行速度快，不依赖语言环境运行，跨平台差
2）解释型跨平台好，一份代码，到处使用，缺点是执行速度慢，依赖解释器运行

高级语言，按照翻译方式分为

#1. 编译型（翻译一次得到可执行的结果，下次即可直接用，不需再用编译器翻译）（翻译工具：编译器）：
	如C、GO，将代码一次性全部编译成二进制后再执行。
	优点：执行速度快。
	缺点：开发效率低，不能跨平台。

#2. 解释型（每次执行程序都需要解释器）：
	如python，逐行解释成二进制，逐行运行。
    优点：调试方便，开发效率高，可以跨平台。
    缺点：执行速度慢。

执行效率：

机器语言>汇编语言>高级语言（编译型>解释型)

开发效率：相反

3.python的种类

Cpython：官方推荐解释器。可以转化成C语言能识别的字节码。
Jpython: 可以转化成Java语言能识别的字节码。
Ironpython：可以转化成.net语言能识别的字节码
pypy: 动态编译。

三、语法

1.交互式环境（cmd)

代码写到交互式环境，输入代码立即得到结果，是用来调试代码的，不能永久保存代码。

#在python3中
input：用户输入任何值，都存成字符串类型

#在python2中
input：用户输入什么类型，就存成什么类型
raw_input：等于python3的input

2.文件/脚本的方式

1）python3 程序的文件路径即：

C:\Users\60462>python3 ‪E:\project\diedaiqi.py

2）文件可以永久保存代码

强调1：python程序文件的后缀名任意，可以是txt，但应规范命名.py

强调2：

如python3 C:\face\a.txt运行python程序经历三个阶段：

（1）先启动python解释器

（2）python解释器会讲a.txt的内容当作普通的文件内容读入内存

（3）python解释器开始解释执行刚刚读入内存的内容，然后将其显示到屏幕中

.py文件前两步骤和上面一样，最后一步是开始识别python语法

3.变量 (重点)

(1)、什么是变量
    量：衡量状态
    变：事物的状态是可以发生变化的

(2)、为何要用变量
    变量是为了控制计算机能够像人一样去记忆下事物的状态
    并且记录的状态是可以发生变化的

 变量其实是一种控制计算机把数据存起来的机制，存到内存中.
 程序=数据+逻辑

3.1变量名

变量全部由数字，字母下划线任意组合。
不能以数字开头。
- 不能是python的关键字。
  - [‘and’, ‘as’, ‘assert’, ‘break’, ‘class’, ‘continue’, ‘def’, ‘del’, ‘elif’, ‘else’, ‘except’, ‘exec’, ‘finally’, ‘for’, ‘from’, ‘global’, ‘if’, ‘import’, ‘in’, ‘is’, ‘lambda’, ‘not’, ‘or’, ‘pass’, ‘print’, ‘raise’, ‘return’, ‘try’, ‘while’, ‘with’, ‘yield’]
- 要具有描述性。name= ‘太白金星’
- 最好不要使用中文、拼音。
- 不能过长。
- 推荐
  - 驼峰体：AgeOfOldboy = 73
  - 下划线：age_of_oldboy = 73

x8 = 100  # True
b__ = 12  # True
4g = 32  # False
_ = 11  # True
*r = 12  # False
r3t4 = 10  # True
t_ = 66  # True

# 变量的小高级：
# 先看=右边，将等号右边的值赋给等号左边的变量
age1 = 18
age2 = age1
age3 = age2
age2 = 12
# print(age1,age2,age3)  # 18 12 18

where：

代指一些复杂过长的数据。

content = 'sfkdsjalfjdslfksdjkfhsdajkfhsdjkfshdfsdkfhsdkfjsldakfjsdaflsdafjshdafjkdsfhkjsdlf

fskdfhsdkfhsdkjfhsdkjfhskdfhsdkjfhsdkfkhsdflsafksjdfhskdajfhskdjfhskda’

3.2变量

先定义后引用

变量的三大组成部分：
# 变量名：相当于门牌号，用来访问/引用值
# =：是把变量值的内存地址绑定给变量名
# 变量值：就是我们记录的状态，也就是程序中的数据

3.3id

id号，又称之为身份，id反映的是内存地址，id相同内存地址则相同

1)id不同，代表内存空间不同，但是不同的内存空间中可以存放相同的值,如：x=257,y=257 print(id(x))→4494198128 print(id(y))→4494198192  

2)id相同，意味着type和value必定相同

4.常量

why :生活中一直不变的：π，身份证号码，历史发生的时间

what: 常量：一直不变的量。python中没有真正的常量，为了应和其他语言的口味，全部大写的变量称之为常量。

how：将变量全部大写，放在文件的最上面。

where：设置一些不变的量：身份证号，id，

BIRTH_OF_CHINA = 1949

# 常量
# 约定俗成不能改变
NAME = '太白'
# print(NAME)

5.注释（重点）

why：文言文中对一些晦涩难懂的成语或者经典的出处解释说明。便于你理解。便于你理解对方的代码，自己的代码。

注释可以用中文或英文，但不要用拼音

how：

单行注释： #

多行注释： ‘’‘被注释内容’’’ “”“被注释内容”""

where:

难以理解的代码后面，加注释。

函数，类，文件都需要注释，解释说明。

6.基础数据类型初识（重点）

什么是数据？为何要有多种类型的数据？

#数据即变量的值，如age=18，18则是我们保存的数据。
#变量的是用来反映/保持状态以及状态变化的，毫无疑问针对不同的状态就应用不同类型的数据去标识

6.1 数字

6.1.1int(整型)

1 ，2， 123， …

+,-,*,/,比较运算
一个**=是赋值，==是判断是否相等，！=**是不等
```
i = 100
i1 = 2
i2 = i*i1
print(i2)
```

6.1.2long（长整型）

在Python3里不再有long类型了，全都是int

6.1.3complex复数型

虚数由实部和虚部两个部分构成：

a = 4.7+0.666j
print(a)
print(a.real) # 输出实部 →4.7
print(a.imag) # 输出虚部→0.666
print(a.conjugate()) #输出该复数的共轭复数→(4.7-0.666j)
# 其中，conjugate( )为complex类的内置函数，作用为输出复数的共轭复数。
# 其中，real可以为int、long、float或字符串类型；而image只能为int、long、或float类型。

注意：如果第一个参数为字符串，第二个参数必须省略，若第一个参数为其他类型，则第二个参数可以选择。

>>> complex("1")  # 当做字符串处理 (1 + 0j)
>>> complex(1)    # 数字
(1 + 0j)
# 注意：这个地方在"+"号两边不能有空格，也就是不能写成"1 + 2j"，应该是"1+2j"，否则会报错
>>> complex("1+2j")
(1 + 2j)

至少得有复数，可无实数。如：91j是复数

3+5j→3:实数 5j:虚数

6.2 flaot(浮点型)小数

作用：记录salary、height、weight

+,-,*,/和比较运算

整型和浮点型可以混用，但字符串不可

print(“a”>1) False

6.3 str(字符串)

str：凡是用引号引起来的数据就称之为字符串。’ ‘, " ", ‘’’ ‘’’ “”" “”"

作用：记录一些描述性的状态，如名字性别、消息等

只能 + 和 *

# str:
s1 = 'day01'
s2 = "Python22期"
s2 = '''Python22期'''

# 单双引号可以配合使用

# content = 'I am taibai, 18 year old'
# content = "I'm taibai, 18 year old"

# 三引号：换行的字符串
msg = '''
今天我想写首小诗，
歌颂我的同桌，
你看他那乌黑的短发，
好像一只炸毛鸡。
'''
# print(msg)

# str + str  *** 字符串的拼接，效率极低
用这种"my name is %s" %"alingna"
# str 只能 + 和 *

#注意1:字符串的拼接只能是双方都是字符串，不能跟数字或其它类型拼接
#注意2：字符串相加的效率不高
字符串1+字符串3，并不会在字符串1的基础上加字符串2，而是申请一个全新的内存空间存入字符串1和字符串3，相当字符串1与字符串3的空间被复制了一次，
s1 = 'alex'
s2 = 'sb'
# print(s1 + s2)
# 结果：alexsb

# str * int
# s1 = '坚强'
# print(s1*8)
# 结果：8个坚强

6.4 bool (布尔类型)：

用于条件True False（id地址是固定的）

注意：所有数据类型都自带布尔值

1、None，0，空（空字符串，空列表，空字典等）三种情况下布尔值为False
2、其余均为真

判断变量指向的是什么数据类型？ type()

# bool : True False
# print(2 > 1)→True
# print(10 < 3)→False
# print("egon" == "egon")→True
# s1 = '100'
# s2 = 100
# print(s1,type(s1))
# print(s2,type(s2))
# 结果：
	100 <class 'str'>
	100 <class 'int'>

6.4.1显式的布尔值

        # 直接定义布尔类型的变量值
            tag=True
        # 通过比较运算得到布尔值
            10 == 10
            3 > 2

6.4.2隐式的布尔值

如：1 and 2 (1和2都是真)
隐式的布尔值为False的数据类型有：0，None，空(指空字符串、空列表、空字典)

 print(bool(0))→False
 print(bool(None))→False
 print(bool(""))→False
 print(bool([]))→False
 print(bool({}))→False
    
 print(bool(1))→True
 print(bool([1,2]))→True

6.5可变、不可变类型

1、可变类型:list,dict
在值改变的情况下，id号不变，也就是说内存地址不变，证明就是在改原来内存空间中的值，即原值可变。如：
l1=[111,"aaaa"]
print(id(l1))→2424154241480
l1[0]=222222
print(l1)
print(id(l1))→2424154241480

dic={'k1':111,'k2':222}
print(id(dic))→2393444460800
dic['k1']="abc"
print(dic)→{'k1': 'abc', 'k2': 222}
print(id(dic))→2393444460800

2、不可变类型:int、float、str（因只能整体改，不能单独改其中一个数字/字母）
在值改变的情况下，id号也跟着变了，也就是说内存地址变了，证明不是在改原来内存空间中的值，而是申请了新的内存空间，产生了新的值，即原值不可变.如：
x=10
print(id(x))→1941990704
x=11
print(id(x))→1941990736

7.列表list

按位置取值，是有序的
存储多个任意类型的值（用中括号，逗号隔开），列表里的元素可重新赋值，重新赋值\取值时也用中括号。索引对应值，索引从0开始。

#       0       1       2                3
# l = [111, 333.3333, "abc", [444444, 5555, 66666,["aaa","bbbb"]]]
# print(l[2])→abc
# print(l[3][0]) →444444
# print(l[-1][-1])→['aaa', 'bbbb']

# 练习题1：存放一个人信息（名字、年龄、多个爱好）
# egon_info = ["egon", 18, ["play", "movie"]]
# 练习题2：存放多个人信息（名字、年龄、多个爱好）
# info = [
#     ["egon1", 18, ["play", "movie"]],
#     ["egon2", 19, ["read"]],
# ]
# print(info[1][2][0])→read

8.字典dict

用在要取有具体含义的元素，是无序的
定义与使用：在{}内用逗号分隔开多个key:value,其中value可以是任意类型（多种属性），但key必须是不可变类型即不能是可变类型列表、字典；key通常为字符串
当报TypeError: unhashable type: ‘list’ → 应用不可变类型却用了可变类型
字典里的元素可重新赋值，重新赋值\取值时也用中括号。

info={"name":"egon","age":18,"gender":"male","hobbies":["play","music"]}
print(info["name"]→egon
print(info["age"])→18
print(info["hobbies"][1])→music

# 练习题：存放多个人信息（名字、年龄、多个爱好）
info = [
    {
        "name": "egon1",
        "age": 18,
        "level": 10,
        "hobbies": ["play", "movie"]

    },
    {
        "name": "egon2",
        "age": 19,
        "level": 11,
        "hobbies": ["read"]
    },
]
print(info[1]["level"])→11

改变字典里的值

dic={"k1":111,"k2":222}
del dic['k1'] # del指删除
print(dic)→{'k2': 222}
dic["kkk"]=111
print(dic)→{'k2': 222, 'kkk': 111}

9.用户交互input输入

why: 网页上，app 输入账号与密码。

what：用户交互input

how：

# input: 出来的全部都是字符串类型。
# 例一
inp_age=input("请输入您的年龄>>>: ") 
print(inp_age+1) # "18"+1
结果：
请输入您的年龄>>>: 18（自己手动输入）报错
(因18是字符串无法与数字相加)
# 正确：
inp_age=input("请输入您的年龄>>>: ") 
inp_age=int(inp_age) # int会把纯数字的字符串转换成int型
print(inp_age+1) # "18"+1
结果：
请输入您的年龄>>>: 18
    19
# 例2
inp_pwd=input("请输入您的密码>>>: ")  # "123"
print(inp_pwd == 123) # "123" == 123
结果：123（手动输入） False
# 正确：
inp_pwd=input("请输入您的密码>>>: ")  # "123"
print(inp_pwd == "123") # "123" == "123"
结果：123  True
# 执行脚本就会发现，程序会等待你输入姓名后再往下走输入密码，然后回车即出现结果。
username = input('请输入用户名：')
password = input('请输入密码：')
# type 是函数，是方法，获取类型
print(username,type(username))
print(password,type(password))
结果：
请输入用户名：alingna
请输入密码1234
alingna <class 'str'>
1234 <class 'str'>
# 了解
python2中raw_input功能与python3中的input功能一模一样

9.1格式化输出%s

%s:字符串占位符，可以接受字符串、数字

%d:数字占位符，只能接收数字

# 要求用户输入信息，然后打印成固定的格式
name=input('your name: ')
age=input('your age: ')
print("my name is %s my age is %s" %(name,age)) # %s表占位符
# 结果：
your name: alingna(手动)
your age: 23(手动)
my name is alingna my age is 23

print("my name is %s" % "egon")→my name is egon
print("my name is %s my age is %s" % ("egon", 18))→my name is egon my age is 18
print("my name is %s my age is %s" % ("egon", [1,2,3]))→my name is egon my age is [1, 2, 3]

python中%r和%s的区别

1)%r用rper()方法处理对象

2)%s用str()方法处理对象
例一、当处理int对象，两者处理结果一样

print("I am %d years old." % 22)→I am 22 years old

print("I am %s years old." % 22)→I am 22 years old

print("I am %r years old." % 22)→I am 22 years old

例二、%r 给字符串加了单引号

text = "I am %d years old." % 22
print("I said: %s" % text)→I said: I am 22 years old.
print("I said: %r" % text)→I said: 'I am 22 years old.'

例三、

import datetime
d = datetime.date.today()
print("%s" % d)→2020-07-01
print("%r" % d)→datetime.date(2020, 7, 1)

10.基本运算符

10.1算数运算

算数运算符通常用于数字类型之间进行，但是+号和*比较特殊可以用于其他类，但是仅限于同种类型之间进行

例：

l1=[1,2,3]
l2=[4,5,6]
print(l1 + l2)→[1, 2, 3, 4, 5, 6]
print(l1*3)→[1, 2, 3, 1, 2, 3, 1, 2, 3] # 即列表重复3遍

print(10 / 3)→3.3333333333333335
print(10 // 3)→3 # 取商
print(10 % 3) # 取余数即取模 →1
print(10 ** 2)→100 # 指10^2

10.2比较运算

== 是否相等 #True or False

！=是否不相等 # True or False

字符串比大小是按顺序来比大小z比a大；如：print(“abz” > “abcdef”) # True
列表比大小也是对应位置比大小

l1=[1,'abc',18]
l2=["a",'abc',18]
l1 > l2 # 报错，对应位置的值必须是同种类型才可以

l1=[1,'abc',18,111,222,333]
l2=[2,'abc',18]
print(l2 > l1) # True

10.3赋值运算符

10.3.1各种运算符

age = 18
# age += 1  # age = age + 1
# print(age)→19

age *= 100 # age = age * 100
print(age)→1800

b -= a # b = b - a
b /= a # b = b / a
b //= a # b = b // a (取商)
b %= a # b = b % a (取余数/取模)
b **= a # b = b ** a(b^a)

10.3.2链式赋值

z = y = x = 10
print(x, y, z)→10 10 10
print(id(x), id(y), id(z))→1941990704 1941990704 1941990704

10.3.3交叉赋值

m = 111
n = 222

temp=m
m=n
n=temp
print(m, n)→222 111 
m, n = n, m #将=号右边的值即n,m赋值给m,n
print(m, n)→111 222

10.3.4解压赋值

10.3.4.1列表解压赋值

 # 左侧变量名的个数必须与包含的值的个数相同，多一个不行，少一个也不行，否者报错
salaries = [1.1, 2.2, 3.3, 4.4, 5.5]
mon0, mon1, mon2, mon3, mon4 = salaries
print(mon0)→1.1
print(mon1)→2.2
print(mon2)→3.3
print(mon3)→4.4
print(mon4)→5.5
# 只取前面几个变量名
salaries = [1.1, 2.2, 3.3, 4.4, 5.5]
mon0, mon1, mon2, *_ = salaries
print(mon0)→1.1
print(mon1)→2.2
print(mon2)→3.3
print(_)→[4.4, 5.5] # -废弃的变量名
# 取后面几个变量名
salaries = [1.1, 2.2, 3.3, 4.4, 5.5]
*_, x, y, z = salaries
print(x)→3.3
print(y)→4.4
print(z)→5.5
# 取前后变量名
salaries = [1.1, 2.2, 3.3, 4.4, 5.5]
x, *_, z = salaries
print(x)→1.1
print(z)→5.5

10.3.4.2字典解压赋值

对于字典来说解压赋值取出来的是字典的key

dic = {"k1": 111, "k2": 222}
x, y = dic
print(x, y)→k1 k2

10.3.4.3字符串解压赋值

a,b,c,d,e="happy"
print(a,type(a))→h <class 'str'>
print(b)→a
print(c)→p
print(d)→p
print(e)→y

10.4逻辑运算

not: 把布尔值结果取反，即"非"的意思。如print(not 10 > 3)→False
and：左右两个条件同时为True，最终结果才为True.如print(10 > 3 and 3 == 3)→True
or:有一个为真即为真。
   如：print(False or True)→True  print(False or False)→False

10.4.1短路运算

逻辑运算的结果一旦可以确定，那么就以当前处计算到的值作为最终结果返回

print(10 and 0 or '' and 0 or 'ab' or  'egon' =='dab' and 333 or 10 > 4) # ab

短路运算面试题：(隐式布尔值)

# 算到哪个位置结束就把那个位置的值当做结果返回
print(1 or 3)→1 # or有一个为真即为真，故到1即返回结果 
print(1 and 3)→3 # and第一个为真则要都判断为真才结束
print(0 and 2 and 1)→0 # 0为假，and中有一个假即假
print(0 and 2 or 1 or 4)→1 # F 0r 1 → 1
print(0 or False and 1)→False # 0 or False → False

三者的优先级关系：not>and>or，同一优先级默认从左往右计算。

'''
原理为：
(1) not的优先级最高，就是把紧跟其后的那个条件结果取反，所以not与紧跟其后的条件不可分割

(2) 如果语句中全部是用and连接，或者全部用or连接，那么按照从左到右的顺序依次计算即可

(3) 如果语句中既有and也有or，那么先用括号把and的左右两个条件给括起来，然后再进行运算

(4)括号可以改变优先顺序
'''
>>> (3>4 and 4>3) or (1==3 and 'x' == 'x') or (not 3=3)
False

10.5身份运算is与==

==判断的是值是否相等

x = ['a', 'b']
y = ['a', 'b']
print(x == y)→True

is判断的是id是否相等（只用在None True False）

x = ['a', 'b']
y = ['a', 'b']
print(id(x))→2707237517768
print(id(y))→2707237142920
print(x is y)→False
# None就只有一个固定的位置
x=None
y=None
# print(x == None)
print(x is None)→True 
print(x is y)→True

x = 10
y = 10
print(x == y)→True
print(x == 10)→True
print(x is y)→True # 不要这么用
print(x is 10)→True # 不要这么用

1)is判断的结果为True，即二者的id一样，即二者内存地址一样，即二者就是一个东西，即值一定相等
2)如果==判断的结果为True，即二者的值一样，那么二者的内存地址可能不一样

如果要判断一个变量是否等于None、True、False，推荐使用is去判断

11.流程控制语句if

完整结构：

if 条件1:
    子代码块1
elif 条件2:
    子代码块2
elif 条件3:
    子代码块3
else:
    子代码块

11.1单独if

inp_name=input('你的名字： ')
if inp_name == "egon":
    print('输入正确')

print('其他代码')

11.2 if+else 二选一

# 例一
age = input('请输入年龄：')
if int(age) > 18:
    print('恭喜你，成年了')
else:
    print('小屁孩儿')

# 例二
inp_name = input('你的用户名： ')
inp_pwd = input('你的密码： ')

if inp_name == "egon" and inp_pwd == "123":
    print('登录成功')
else:
    print("刚刚输入的用户名或密码错误")

11.3if elif elif … 多选一

# 例一
num = int(input('猜点数：'))

if num == 1:
    print('晚上请你吃饭')
elif num == 3:
    print('一起溜达')
elif num == 2:
    print('请你大宝剑')

11.4if elif elif … else 多选一

# 例一
score=int(input('请输入您的成绩: '))

if score >= 90:
    print('优秀')
elif score >= 80:
    print('良好')
elif score >= 70:
    print('普通')
else:
    print('很差')
    
# 例二
today=input('>>: ')
if today in ['Saturday','Sunday']:
    print('出去浪')
elif today in ['Monday','Tuesday','Wednesday','Thursday','Friday']:
    print('上班')
else:
    print('''必须输入其中一种:
    Monday
    Tuesday
    Wednesday
    Thursday
    Friday
    Saturday
    Sunday
    ''')

补充

print(20 >= age >= 18) # age大于等于18小于等于20
print(18 <= age <= 20) # age大于等于18小于等于20

11.5嵌套的if

# 例一
username = input('请输入用户名：')
password = input('请输入密码：')
your_code = input('请输入验证码：')

if your_code == 'qed':
    if username == 'alina' and password == '123':
	    print('登录成功')
    else:
	    print('账号或者密码错误')
else: # else是最后一层
    print('验证码错误')
    
# 例二    
if 10 > 3: # F的话→ok4
    if 1 == 1: # 如果只这步F的话→ok3 
                                ok4
        print('ok1')
        print('ok2')
    print('ok3')
print('ok4')
# 以上都正常运行的话打印
ok1
ok2
ok3
ok4

12.流程控制语句while

如果条件为True，那么循环体则执行，执行完毕后再次循环，重新判断条件。。。
如果条件为False，那么循环体不执行,循环终止

#打印0-10
count=0
while count <= 10:
    print('loop',count)
    count+=1

#打印0-10之间的偶数
count=0
while count <= 10:
    if count%2 == 0:
        print('loop',count)
    count+=1
 
#打印0-10之间的奇数
count=0
while count <= 10:
    if count%2 == 1:
        print('loop',count)
    count+=1

12.1死循环

# 结果会一直打印
第1步
第2步
第3步
while True:
    print("第1步")
    print("第2步")
    print("第3步")

12.2结束while循环的方式False与break

方式一：把条件变为False，不会立刻结束循环，会等到把本次循环体代码都运行完毕后，**
下一次循环开始重新判断条件时才会结束**

tag = True
while tag:
    inp_user = input('用户名：')
    inp_pwd = input('密码：')
    if inp_user == "egon" and inp_pwd == "123":
        print('登录成功')
        # 结束循环
        tag = False
    else:
        print('账号或密码错误，请重新输入')

    print('其他代码')
# 结果：
用户名：egon
密码：123
登录成功
其他代码

方式二：break结束本层循环，只要运行到break就会立刻结束while循环，本次循环的后续代码都不会执行力

while True:
    inp_user = input('用户名：')
    inp_pwd = input('密码：')
    if inp_user == "egon" and inp_pwd == "123":
        print('登录成功')
        # 结束循环
        break
    else:
        print('账号或密码错误，请重新输入')

    print('其他代码')

12.3while循环的嵌套

while True:
    while True:
        while True:
            break # 结束上一个while循环，即第三个while循环
        break
    break
    
tag=True
while tag:
    while tag:
        while tag:
            tag=False # 以上tag都为True
#例一
n = 1
while n <= 3: # 2 <= 3
    print('外层循环第%s次' % n)
    i = 1
    while i <= 2:
        print('========>内层循环第%s次' % i)
        i += 1
    n += 1
# 结果：
外层循环第1次
========>内层循环第1次
========>内层循环第2次
外层循环第2次
========>内层循环第1次
========>内层循环第2次
外层循环第3次
========>内层循环第1次
========>内层循环第2次

12.4 while+continue

遇到continue后，结束本次循环，后面的代码不再执行，循环从continue那返回重新执行

# 打印1 2 3 5
n = 1
while n <= 5:
    if n == 4:
        n+=1 # n = 5
        continue
        # n+=1 # 切忌在continue同一级别之后添加代码
    print(n)
    n += 1

12.5 while+else

else：一般只与if 搭配不同，在Python 中还有个while …else 语句，while 后面的else 作用是指，当while 循环正常执行完，中间没有被break 中止的话(即非正常结束)，就会执行else后面的语句。

ps:循环条件由真改为假是正常结束

# print:1 2 3 4 5 else的代码运行
n = 1
while n<=5:
    print(n)
    n+=1
else:
    print('else的代码运行')
    
# print:1 2 3
n = 1
while n<=5:
    if n == 4:
        break #非正常结束
    print(n)
    n+=1
else:
    print('else的代码运行')

「已注销」

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
从python入门到人生巅峰

一、python是一门编程语言1.1编程语言本质就是一门语言，是用来人与计算机沟通。1.2编程就是把做事的步骤/业务逻辑给翻译下来1.3程序存放有程序代码的文件就是程序或叫**软件。（ps:硬件以外的都是软件。操作文件即操作硬盘→文件就是操作系统提供给应用程序/用户操作硬盘的一种功能。所以以后写程序只要写文件即可。）1.3.1程序的区分计算机硬件是死的，计算机硬件的运行都受软件控制，所以说，软件相当于计算机的灵魂开发程序本质是在控制硬件具体来说软件分为两种：
复制链接

扫一扫