python之基本介绍

（1）什么是python

python 是一门编程语言

python是一门面向对象，解释型的动态类型的编程语言

guido van rossunm （吉多*范罗苏姆）

在1989年发明，第一个公开发行版本与1991年；

python在市面上的版本：

python 2.7 （以前用的非常多）

目前用的版本是3.0 版本

最新的版本3.121版本

目前我们学的3.7版本

（2）什么是面向对象？

python 中一切皆为对象，对事物的描述和方法系统的定义为一个类，在这个类中的具体的实例，我们就说对象；

例如：人：类======== lv 对象

（3）什么解释型？

python程序执行时无需先进行编译成二进制代码，直接在执行过程中对语句一条条进行编译；

例如：java 包装jdk编译，python不需要，可以直接编译

（4）什么动态类型？

指python程序在运行时可以改变其结构，新的函数可以被引进，已有函数可以被删除；

（5）python有哪些特点？

简单易学免费开源可拓展性强可移植具有丰富的第三方类和库

（6）python应用在哪些领域？

网页开发，可视化界面开发，系统编程，数据分析，网络爬虫，自动化脚本开发，数据分析，ai人工智能，大数据，云计算

（7）python的打印的方式？

print（）

python的运用

基础用法

命令行必须要顶格输入，不能开头有空格

print('') 打印

括号中必须加上单引号或者双引号（必须是英文的符号）

在引号中间输入代码指令

注释

# 注释内容或 ctrl+/ 单行注释

鼠标选择多行+ctrl+/ 多行注释

'''注释内容''' 自动多行注释引号中的内容

变量

通过定义变量的方法来实现输出

定义一个变量名称：字符，下划线，数字组合

变量名规则：字母或下划线开头，不能以数字开头

引用： print(变量名)

查看字符类型

 查看字符类型   print(type(变量名))
<class 'int'>  
<class 'str'>

引号的用法

单、双、三引号都能单独使用；

单引号可以包含双引号，不能包含单引号和三引号

双引号中可以包含单引号和三引号，不能包含双引号

三引号可以包含单引号和双引号，不能不能包含三引号

三个引号都不能包含本身

Python格式输出

%s :字符串 (采用str()的显示)

%c :单个字符

%d:十进制整数

%i :十进制整数

%o:八进制整数

%x:十六进制整数

%f:浮点数

%% :字符"%"

#  %s  将int类型转换成str类型显示
b = 333
print(type(b))       # <class 'int'>
print(type('%s'%b))  # <class 'str'>

#   %c   只能单个字符
b = '1'
print('%c'%b)

# %d  十进制整数
b = 15
print('%d'%b)

# %o 八进制整数
b = 15
print('%o'%b)

# %x 十六进制整数
b = 15
print('%x'%b)

# %f 浮点数
b = 15
print('%f'%b)

# '进制%%'    整数百分比
b = 15
print('%d%%'%b)

常用类型表

python关键词

这些关键词在Python编程中拥有特殊的意义，不能用作变量名、函数名或其他标识符。使用它们时需要遵循Python的语法规则。在编写代码时，应尽量避免使用这些关键词作为变量或函数的名字，以免引发语法错误。

False          # 假
input          # 输入
None           # 无（空）
True           # 真
and            # 和
as             # 作为 （重命名）
assert         # 断言
async          # 异步
await          # 等待
break          # 跳出循环
class          # 类
continue       # 继续
def            # 定义函数
del            # 删除
elif           # 否则如果
else           # 否则
except         # 捕获异常
finally        # 最终（无论如何都执行）
for            # 循环
from           # 从...导入
global         # 全局
if             # 如果
import         # 导入
in             # 在...中
is             # 是
lambda         # 匿名函数
nonlocal       # 非局部（引用外层变量）
not            # 非，不是
or             # 或
and            # 与
pass           # 空操作（占位符）
raise          # 抛出异常
return         # 返回
try            # 尝试
while          # 当...时循环
with           # 使用（上下文管理器）
yield          # 生成器函数返回数据
list           # 列表
type           # 类型

Python常见的运算符

算术运算符

a=5
b=6
print(a+b)   #返回值11   a和b相加
print(a-b)   #返回值-1   a和b相减
print(a*b)   #返回值30   a和b相乘
print(a/b)   #返回值0.833a和b相除
print(a%b)   #返回值5  除法中的余数
print(a**b)  #返回值15625  a的b次方
print(a//b)  #返回值0  a除于b保留整数

赋值运算符

a=9
b=2
# a+=b
# print(a)   #返回值11   等同于a=a加b
#
# a-=b
# print(a)    #返回值7   等同于a=a减b
#
# a*=b
# print(a)    #返回值18   等同于a=a乘b
#
# a/=b
# print(a)    #返回值4.5   等同于a=a除b
#
# a**=b
# print(a)    #返回值81   等同于a=a的b次方
#
# a//=b
# print(a)    #返回值4   等同于a=a除b 保留整数
#
# a%=b
# print(a)      #返回值1   等同于a=a除b 的余数

比较运算符

比较运算符的结果永远为True或False

a=9
b=2
print(a==b)    #返回值False
print(a>b)     #返回值True
print(a<b)     #返回值False
print(a>=b)    #返回值True
print(a<=b)    #返回值False
print(a!=b)    #返回值True

逻辑串运算符

a=5
b=3
c=1
print(a>b and b>c)    #返回值True 与 （两个条件同时瞒住）
print(a>b and b<c)    #返回值True 与
print(a>b or b<c)    #返回值True 或 (两个条件满足一个就可以)
print(not(b<c))    #返回值True 非   不包含就是对的
print(not(b>c))    #返回值False 非  包含就是错的

成员运算符

name=[1, 2 , 3 , 4 , 5 , 6 , 7, 8]
print(1 in name)        # 返回值True   在范围内
print(9 in name)        # 返回值False  不在范围内
print(1 not in name)    # 返回值False   在范围内
print(9 not in name)    # 返回值True    不在范围内

位运算符

按位与 &

规则：两两为真取，一真一假不取

a=5
b=3
# a：0000 0101
# b：0000 0011
print(a&b)   # 输出1   0000 0001

按位或 |

规则：一真一假取真，一假一真取真，两两为真取真，两两为假不取

a=5
b=3
# a：0000 0101
# b：0000 0011
print(a|b)   # 输出7   0000 0111

按位异或 ^

规则：一真一假取真，一假一真取真，两两为真不取，两两为假不取

a=5
b=3
# a：0000 0101
# b：0000 0011
print(a^b)   # 输出6   0000 0110

按位取反 ~

a=5
b=3
print(~a) #公式-（a+1）  按位取反
# -（5+1）=-1
print(~b)

向左运动运算符>>

a=5
b=3
# a：0000 0101
# b：0000 0011
print(a>>b)    #输出0    0000 0000

向右移动运算符<<

a=5
b=3
# a：0000 0101
# b：0000 0011
print(a>>b)    #输出40    0010 1000

字符，列表，元组，字典，集合

字符类型

索引

索引在公司中一般也叫下标，或角标

定义：可我们可以直接使用索引来访问序列中的元素，同时索引可分为正向索引和负向索引两种，而切片也会用到索引，如下图：

Python中有序列：字符，列表，元组

无序：集合

正向索引：从0开始

负向索引：-1开始

切片

定义：切片是指对操作的对象截取其中一部分的操作，字符串，列表，元组都支持切片操作

切片的语法：【开始索引：结束索引：步长】

备注：显示结果：包含开始值，不包含结束值

zimu="abcdefghijklmnopq"
print(zimu[1])           # b   表示正索引1开始
print(zimu[1:3])         # bc  包含开始值，不包含结束值 
print(zimu[1:9:2])       # bdfh  1是开始值 ，9是结束值，2是步长
print(zimu[3:])          # defghijklmnopq   3表示开始值，为空代表后面所有
print(zimu[::-1])        # qponmlkjihgfedcba  反转负索引显示
print(zimu[:])           # abcdefghijklmnopq  显示所有的内容 
print(zimu[-1:-5:-1])    # qpon  负索引-1是开始值，-5结束值，-1是步长
print(zimu[-5:-1])        #mnop  从-5开始值 负索引取到-1结束值 ， 不包含-1

字符串

capitalize 首字母大写
title 每段字母的首个字母大写
count 统计字符个数
join 把字符集中每个字符用符号分割
split 通过指定的内容进行分割，不显示被指定的内容
strip 删除字符集中开头和结尾，字符相同也可以
lstrip 删除字符集首字符
rstrip 删除字符集末位字符
startswith 判断字符集是不是以某个字符开头
endswith 判断字符集是不是以某个字符结尾
find 从左往右查字符在第几位
rfind 串右往左查字符在第几位
replace 替换相同字符
upper 将字符集所有小写字符换成大写
lower 将字符集所有大写字符换成小写
isdigit 判断字符集是不是全数字
isalpha 判断字符集是不是全字母
isalnum 判断字符串中是全是字母或全是数字或数字和字母组合
islower 判断是不是都小写
isupper 判断是不是都大写

set 去重

#字符串
xnt='hzdcs41wlc'
xnt2='aaaabbbbcccc'
xnt3='AAAABBBBCCCC'
# capitalize 首字母大写
print(xnt.capitalize()) # 返回值：Hzdcs41wlc
# title  每段字母的首个字母大写
print(xnt.title()) # 返回值：Hzdcs41Wlc
# count 统计字符个数
print(xnt.count('z')) # 返回值：1
# join 把字符集中每个字符用符号分割
print('/'.join(xnt)) # 返回值;h/z/d/c/s/4/1/w/l/c
# split 通过指定的内容进行分割，不显示被指定的内容
print(xnt.split('s')) # 返回值：['hzdc', '41wlc']
# strip  删除字符集中开头和结尾，字符相同也可以
print(xnt.strip('h.c')) # 返回值：zdcs41wl
# lstrip  删除字符集首字符
print(xnt.lstrip('h')) # 返回值：zdcs41wlc
# rstrip 删除字符集末位字符
print(xnt.rstrip('c')) # 返回值：hzdcs41wl
# startswith  判断字符集是不是以某个字符开头
print(xnt.startswith('z'))  # 返回值:对的True/错的False
# endswith   判断字符集是不是以某个字符结尾
print(xnt.endswith('c'))  # 返回值:对的True/错的False
# find 从左往右查字符在第几位
print(xnt.find('w')) # 返回值 ：7
# rfind  串右往左查字符在第几位
print(xnt.rfind('w'))  # 返回值：2
# replace 替换所有相同字符
print(xnt2.replace('a','s'))  #返回值：ssssbbbbcccc a是原值，b是替换值
# replace 指定替换的次数
print(xnt2.replace('a','s',3))   #返回值：sssabbbbcccc a是原值，b是替换值,3是次数
# upper  将字符集所有小写字符换成大写
print(xnt2.upper()) # 返回值：AAAABBBBCCCC
# lower  将字符集所有大写字符换成小写
print(xnt2.lower())  # 返回值：aaaabbbbcccc
# isdigit 判断字符集是不是全数字
print(xnt2.isdigit())    # 返回值:对的True/错的False
# isalpha  判断字符集是不是全字母
print(xnt2.isalpha())    # 返回值:对的True/错的False
# isalnum   判断字符串中是全是字母或全是数字或数字和字母组合
print(xnt2.isalnum())    # 返回值:对的True/错的False
# istitle  判断首个字母是否大写必须是只有首个字符大小，其他字母为小写
print(xnt2.istitle())    # 返回值:对的True/错的False
# islower 判断是不是都小写
print(xnt.islower())   # 返回值:对的True/错的False
# isupper 判断是不是都大写
print(xnt.isupper())   # 返回值:对的True/错的False
# set  去重
list = [1, 3, 6, 9, 1, 8]
qc=set(list)
print(qc)    返回值:{1, 3, 6, 8, 9}

列表

类型：<class 'list'>

符号：[]

定义：列表list 是一组有序存储的数据，也是python常见的序列值一、序列中的每个元素都分配一个索引，第一个元素的索引是0，第二个元素的索引是1，依次类推，序列都可以进行操作包括索引，切片

定义列表的方法有两种：

方法一：list1=[1,2,3,4] #直接通过[]进行定义

方法二：list2=list（'12345） #直接通过list转换

通过索引添加值（覆盖原有值

# 列表数据
list1=[1,2,3,4,5]
# 替换单个
list1[2]='a'
print(list1)   #返回值：[1, 2, 'a', 4, 5]
# 替换多个
list1[1:]='好好学习天天向上'
print(list1)  #返回值：[1, '好', '好', '学', '习', '天', '天', '向', '上']

列表中的函数

append 添加元素默认添加在最后一位

list1=[1,2,3,4,5]
list2=[6,7,8,9,0]
list1.append('name')
print(list1) #返回值：[1, 2, 3, 4, 5, 'name']

extend ：连接两个列表

list1=[1,2,3,4,5]
list2=[6,7,8,9,0]
list1.extend(list2)
print(list1)  #返回值：[1, 2, 3, 4, 5, 6, 7, 8, 9, 0]

insert（）在指定字符后插入数据

list1=[1,2,3,4,5]
list1.insert(2,'r')
print(list1) #返回值：[1, 2, 'r', 3, 4, 5]

remove删除列表中指定的值，从左开始删除，只删除第一个

ist1=[1,2,3,4,5]
list1.remove(3)
print(list1) #返回值;[1, 2, 4, 5]

del 通过索引删除指定的值

list1=[1,2,3,4,5]
del list1[3]
print(list1) #返回值：[1, 2, 3, 5]

index 查看在列表中字符集的索引值

list1=[1,2,3,4,5]
print(list1.index(4)) #返回值：3

sort 实现列表的升序排列

ist1=[2,3,6,7,4,1,9,8]
list1.sort()
print(list1) # 返回值;[1, 2, 3, 4, 6, 7, 8, 9]

sorted 排序字母和数字都可以排序

list1=[2,3,6,7,4,1,9,8]
print(sorted(list1,reverse=True)) #返回值：降序[9, 8, 7, 6, 4, 3, 2, 1]
print(sorted(list1,reverse=False)) #返回值：升序[1, 2, 3, 4, 6, 7, 8, 9]
list1=['a','c','d','b','e','f','g']
print(sorted(list1,reverse=True))  #返回值：降序['g', 'f', 'e', 'd', 'c', 'b', 'a']
print(sorted(list1,reverse=False))  #返回值：升序['a', 'b', 'c', 'd', 'e', 'f', 'g']

reverse 列表中所有元素反转

list1=[2,3,6,7,4,1,9,8]
list1.reverse()
print(list1)  #返回值：[8, 9, 1, 4, 7, 6, 3, 2]

pop 默认移除列表中最后一个元素,括号内可以选择要移除的值

list1=[1,2,3,4,5]
list1.pop()
print(list1) #返回值：[1, 2, 4, 5]

元组 tuople

元组不可变

定义：元组是python中一种数据结构，元组由不同的元素组成，每个元素可存储不同类型的数据；如字符串，数字，甚至元组，

元组是“写保护”的，即元组中元素作为一个整体，创建后不能做任何修改操作。

当出现一个字符时，加上逗号，（就变成了元组）

xnt=(1,2,3,4,5,'a','b','c')
print(type(xnt))  #返回值：<class 'tuple'>
print(xnt)

元组函数运用

（1）index 索引

xnt=(1,2,3,4,5)
print(xnt.index(5)) #返回值：4

（2）元组需要修改，只能将元组转换成列表，使用列表的函数操作，列表操作完在转换成元组

xnt=(1,2,3,4,5,'a''b','c')   # 数值
print(type(xnt))              # 查看类型为tuple元组类型
xnt1=list(xnt)                # 重命名并转换成列表类型
print(type(xnt1))             # 查看类型为list
print(xnt1)                   # 打  印
xnt1.insert(2,'s')            # 对列表进行操作
print(xnt1)                   # 打印
xnt2=tuple(xnt1)              # 重命名并将列表转回元组
print(type(xnt2))             # 查看类型为tuple元组类型
print(xnt2)                   # 打印

元组和列表的区别：

相同：

1、都是有序，

2、都支切片、迭代等操作

不同：

1、list是可变对象，元组tuple是不可变对象

2、tuple不可变，使用tuple编写的代码更安全

3、列表是[]，元组是()

4、列表的字符类型：list ，元组的字符类型：tuple

字典

字典的字符类型 <class 'dict'>

符号：{}

1、字典（dict）是一种可变容器模型，且可存储任意类型对象

2、字典的每个键，值 key，value 键值对形式

3、键值用：分割，每个键值对之间用逗号分隔

4、整个字典用{}包含

5、字典键唯一，值不是唯一的

定义字典的方法

方法一：通过{}定义字典

xnt={'name':'wangfugui','age':'88',}
print(type(xnt))  #返回值：<class 'dict'>

方法二：通过dict来转换成字典

xnt=[('aa',1),('bb',2),('cc',3)]  # 数值
xnt1=dict(xnt)         # 重命名并转换成dict字典
print(type(xnt1))      # 查看类型 返回值：<class 'dict'>
print(xnt1)            # {'aa': 1, 'bb': 2, 'cc': 3}

字典中常见的函数：

1.添加新的键和值

s={'a': 1, 'b': 2, 'c': 3}   # 字典
s["d"]=4     # 要添加的键和值，'d'是键,4是值
print(s)     # 返回值：{'a': 1, 'b': 2, 'c': 3, 'd': 4}

2.修改已经存在的键的值（键不变，值变）

s={'a': 1, 'b': 2, 'c': 3}
s["c"]=4    # 已经存在键'c',要修改的值4
print(s)    # 返回值：{'a': 1, 'b': 2, 'c': 4}

3.使用keys取出所有键返回列表

s = {'a': 1, 'b': 2, 'c': 3}
print(s.keys())  # 返回值：dict_keys(['a', 'b', 'c'])

使用values取出所有值返回列表

s = {'a': 1, 'b': 2, 'c': 3}
print(s.values())   # 返回值：dict_values([1, 2, 3])

5.取出具体键的值

s = {'a': 1, 'b': 2, 'c': 3}
print(s['c'])  # 返回值：3

6.字典中默认添加元素 setdefault

s = {'a': 1, 'b': 2, 'c': 3}
s.setdefault("d",4)   # 要添加的值
print(s)     #返回值：{'a': 1, 'b': 2, 'c': 3, 'd': 4}
# 插入存在的键值，新值不会覆盖原值（默认值优先级要低于字典中的键值
s={'a': 1, 'b': 2, 'c': 3}
s.setdefault("c",4)  ）
print(s)  # 返回值：{'a': 1, 'b': 2, 'c': 3}

7.clear 清空字典

s = {'a': 1, 'b': 2, 'c': 3}
s.clear()
print(s)  #返回值：{}已清空字典

8.del 删除字典中指定的键，连同值也删除(可以多个同时删除)

s = {'a': 1, 'b': 2, 'c': 3}
del s['b']
del s['c']
print(s)  # 返回值：{'a': 1}

9.for循环遍历字典，

# for循环遍历字典所有的键
s = {'a': 1, 'b': 2, 'c': 3}
for w in s: # w是值的变量
    print(w)   # 返回值：a b c
    
# for循环遍历字典所有的键和值
s = {'a': 1, 'b': 2, 'c': 3}
for w in s:  # w是键的变量，l是值的变量
    print(w,s[w])   # 返回值：a 1 b 2 c 3
    
# 使用items（）完成遍历
    s = {'a': 1, 'b': 2, 'c': 3}
for w,l in s.items():  # w是键的变量，l是值的变量
    print(w,l) # 返回值：a 1 b 2 c 3

10.pop 删除指定的键并返回删除的值

s = {'a': 1, 'b': 2, 'c': 3}
print(s.pop('b'))  #返回值：2

11.get 通过键返回键的值,键不存在就返回none

s = {'a': 1, 'b': 2, 'c': 3}
print(s.get('c'))   #返回值：3

12.popitem 随机删除返回删除字典中的键值对（一般默认删除末尾的键值）

s = {'a': 1, 'b': 2, 'c': 3}
v=s.popitem()  # 给删除的键和值命名
print(v)    # 查看删除的键值 返回('c', 3)
print(s)    # 查看未删除的 返回{'a': 1, 'b': 2}

13.update函数利用一个字典更新另一个字典

s={'a': 1, 'b': 2, 'c': 3}
c={'d': 4, 'e': 5}
s.update(c)  # s合并c  但c不变
print(s)  #返回值：{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
print(c)  #返回值;{'d': 4, 'e': 5}

# 有重复键，显示覆盖的字典中的值
s={'a': 1, 'b': 2, 'c': 3}
c={'a': 4, 'e': 5}
s.update(c)  # s合并c   但c不变
print(s)    #返回值：{'a': 4, 'b': 2, 'c': 3, 'e': 5}
print(c)     #返回值：{'a': 4, 'e': 5}

14.copy函数复制字典

s={'a': 1, 'b': 2, 'c': 3}
v=s.copy()   #复制并命名
print(v)  # 返回值：{'a': 1, 'b': 2, 'c': 3}

集合

最重要功能是去重

第一种：可变集合 set

第二种：不可变集合 frozenset

字符类型：<class 'set'>

可变

# 对列表去重
list=[1,2,3,6,4,4,2,8,8,1] # 数值
s=set(list)    # 重命名并转换为set合集
print(s)    #返回值：{1, 2, 3, 4, 6, 8}

# 对字符去重
list='aabbccddeeff' # 数值
s=set(list)     # 重命名并转换为set合集
print(s)    #返回值：{'a', 'e', 'f', 'd', 'c', 'b'}

集合 set

1.对列表和对字符去重

# 对列表去重
list=[1,2,3,6,4,4,2,8,8,1] # 数值
s=set(list)    # 重命名并转换为set合集
print(s)    #返回值：{1, 2, 3, 4, 6, 8}

# 对字符去重
list='aabbccddeeff' # 数值
s=set(list)     # 重命名并转换为set合集
print(s)    #返回值：{'a', 'e', 'f', 'd', 'c', 'b'}

2.add 集合中添加参数

list=[1,2,3,6,4,4,2,8,8,1]
s=set(list)   #先去重
s.add('b')
print(s)  #返回值：{1, 2, 3, 4, 6, 8, 'b'}

3.remove 删除具体参数

list=[1,2,3,6,4,4,2,8,8,1]
s=set(list)   #先去重
s.remove(8)
print(s)  # 返回值：{1, 2, 3, 4, 6}

4.pop 默认删除集合内首个字符数据

list=[1,2,3,6,4,4,2,8,8,1]
s=set(list)   #先去重
print(s)   #返回值：{1, 2, 3, 4, 6, 8}
s.pop()
print(s)  # 返回值：{2, 3, 4, 6, 8}

5.clear 清除合集所有数据

list=[1,2,3,6,4,4,2,8,8,1]
s=set(list)   #先去重
s.clear()
print(s)   #返回值；set()

6.copy 复制集合

list=[1,2,3,6,4,4,2,8,8,1]
s=set(list)   #先去重
k=s.copy()   #先命名在复制
print(k)    # 返回值:{1, 2, 3, 4, 6, 8}
print(s)    # 返回值：{1, 2, 3, 4, 6, 8}

7.update 将两个合集合并

list=[1,2,3,6,4,4,2,8,8,1]
s=set(list)   #先去重
list2=['a','b','c']
k=set(list2)  #先去重
print(s)
print(k)
s.update(k)    # 连接合并 s连接k
print(s)       # 返回值：{1, 2, 3, 4, 6, 8, 'b', 'a', 'c'}
print(k)       # 返回值：{'b', 'a', 'c'} 被连接不变

不可变集合 frozenset

list=[1,2,3,6,4,4,2,8]
s=frozenset(list)  # 先去重
k=s.copy()        
print(k) #frozenset({1, 2, 3, 4, 6, 8})

判断语句

if和else的运用

判断条件 if中可以使用比较运算符

>,<,!=，==，>=,<=

if（如果）.....else(否则)

单分支：一个if对应一个else

zh=input('请输入账号：')
if zh=='123456':
    print('账号正确')
else :
    print("错误")

多分支：一个if对应多个elif，一个else

zh=input('请输入账号：')
if zh=='1234':
    print('对')
elif zh=='12345':
    print("对对")
elif zh=='1234567':
    print('对对对')
else:
    print('账号错误')

语句嵌套：几个if对应几个else

name=input('账号：')
if name=="dc":
    passwd=input('密码:')
    if passwd=="123456":
        yzm=input('验证码:')
        if yzm =="1234":
            print('登录成功')
        else:print('请输入正确的验证码')
    else:print("请输入正确的密码")
else:print("请输入正确的账号")

三目运算

print（执行语句块1 if 条件 else 执行语句块2 ）

name=input("姓名：")
print("富婆"  if  name=='yy' else "乞丐")   执行语句块2  ）

pass语法

（1）pass 的用法是用来占位

（2）pass是一个空语句

（3）pass是保证语句格式的完整性

（4）pass保证语义完整

name=input("账号：")
if  name=="zt":
    pass
else:
   pass

while循环语句

（1）什么时候进入循环? 当循环条件成立时

（2）什么时候退出循环? 当循环条件不成立时

（3）while语句一定要有循环条件，否则很容易陷入死循环中

条件成立

a=0
while a<5:  # 循环结果小于5 大于5就停止
    a+=1    # a=a+1
    print(a,end='') # 返回值：12345

条件不成立

 a=1
 while a>5:    #a是小于5的，所有条件不成立
    a+=1      # a=a+1
    print(a)  # 空

死循环

a=3
while a>1:    # 当a大于1时停止，但是a一开始就等于3，所有不会停止
      a+=1
      print(a,end='')

无限循环 while True

while True:
    cq=int(input('请输入'))
    if cq==0:
        break
    dn=int(random.randint(1,3))
    if (cq==1 and dn==2) or (cq==2 and dn==3) or (cq==3 and dn==1):
       print('玩家胜利')
    elif cq==dn:
       print('平局')
    elif cq>3:
       print('错误')
    else:
        print('电脑顺利')

案例

# 1、while循环求出 1-100的和
a=0              
sum=0
while a<101:   # 当a>=100时循环结束
    sum+=a     # sum=sum+a
    a+=1       # a=a+1
    print(sum) # 输出值：5050
# 2、while循环求出 1-100的偶数和
a=0
sum=0
while a<101:    # 当a>=100时循环结束
    sum=sum+a  # sum=sum+a
    a+=2        # a=a+1
    print(sum) # 输出值：2550

# 3、while循环求出1-100的奇数和
a=1
sum=0
while a<101:  # 当a>=100时循环结束
    sum=sum+a   # sum=sum+a
    a+=2          # a=a+1
    print(sum)    # 输出值：2500

for循环语句

for循环的语法格式如下：

for ... in ...

先熟悉下range()函数：如果需要遍历一个数字序列，可以使用python中内建的函数range()

函数range（开始值，结束值，步长）

要求：包含开始值，不包含结束值，步长从2开始，1表示没有变化，默认从0开始

# for...in....
for a in range(1,12,2): # 对a内的范围（开始值，结束值，步长）
    print(a,end=',')  # 返回值：1,3,5,7,9,11,

案例


# 1、for循环求出 1-100的和
sum=0        # 定义
for a in range(1,101): 
    sum+=a
    print(sum)  #

# 2、for循环求出 1-100的偶数和
sum=0        # 定义
for a in range(0,101,2):
    sum+=a
    print(sum)

# 3、for循环求出1-100的奇数和
sum=0        # 定义
for a in range(1,101,2):
    sum+=a
    print(sum)

Python的基本