本文所给出的代码是自己整理出来的python基础学习的一些资料，包括一些功能和例子，都均有代码进行举例分析，在python代码中也进行了详细注释，帮助大家理解。学完这些大概就已经入门python了

1.转义字符与原字符

常用的转义字符串
无法直接表示的字符串
换行 \n newline 光标移动到下一个字符串开头
回车 \r return光标移动到本行的开头
水平制表符 \t tab键，光标移动到下一组4个空格的开始处。满4个补充空格
退格 \b 键盘上的backspace键，回退一个字符

在字符串中有特殊用途的字符串
反斜杠 \
单引号 ’
双引号 "

# 常用的转义字符串
# 无法直接表示的字符串
# 换行 \n  newline 光标移动到下一个字符串开头
# 回车 \r return光标移动到本行的开头
# 水平制表符 \t tab键，光标移动到下一组4个空格的开始处。满4个补充空格
# 退格 \b 键盘上的backspace键，回退一个字符# 在字符串中有特殊用途的字符串
# 反斜杠 \\
# 单引号 \'
# 双引号 \"print('hello\nworld') # \  +转义功能的首字母  n -->  newline的首字符表示换行
print('hello\tworld') # \t空4个单元格
print('hello\rworld' ) # \r是world将hello进行覆盖
print("hello\bworld")# \ b是退一个格子，将o进行覆盖
print('http:\\www.baidu.com')
print('http:\\\\www.baidu.com')
print('teacher say :"hello"')
print('teacher say :\'hello\'')# 如果''都一样的话系统默认，需要添加转义字符进行修改，不然会报错
# 原字符不希望字符串中的转义字符起作用，就使用原字符，就是在字符串前面加上r或者R
print(r'hello\nworld')
# 注意事项，最后一个字符不能是反斜杠
# print(r'hello\nworld\') 会error
print(r'hello\nworld\\')

结果：

hello
world
hello   world
world
hellworld
http:\www.baidu.com
http:\\www.baidu.com
teacher say :"hello"
teacher say :'hello'
hello\nworld
hello\nworld\\

2.二进制与字符编码

#二进制与字符编码# 8bit =1byte 字节
# 1024byte = 1KB 千字节
# 1024KB = 1MB 兆字节
# 1024 MB =1GB  吉字节
# 1024GB = 1TB 太字节# 二进制0 ，1
# ASCLL --GB2312（80年推出--简体中文） -- GBK（90年推出--简体中文，繁体）--GB18030（00年推出--简体中文，繁体，藏文等等）
# 其他国家的字符编码--Unicode几乎包含了全世界的字符（所有的均为2个字节） -- UTF-8（中文3个字节，英文一个字节）

3.二进制编码

# 字符和文字都有对应的二进制编码，并且计算机只能识别二进制数
print(chr(0b100111001011000))#
print(ord('乘'))

结果

乘
20056

4.变量定义

# 变量的定义和使用
# 变量是内存中一个带标签的盒子
name = '玛利亚'
# 两者是有区别的，第一个是打印标签的内容，第二个是打印标签
print(name)
print('name')
# 变量由三部分组成
# 标识：表示对象所存储的内存地址，使用内置函数id(obj)来获取
# 类型：表示的是对象的数据类型，使用内置函数type(obj)来获取
# 值：表示对象所存储的具体数据，使用print(obj)可以将值进行打印输出
print('标识:',id(name))
print('类型:',type(name))
print('值:',name)

结果

玛利亚
name
标识: 2173827241232
类型: <class 'str'>
值: 玛利亚

4.数据类型

整数类型
英文名 integer，简写为int，可以表示正数、负数和0
整数的不同表示方式
十进制 默认的进制
八进制 以0o开头
十六进制 以0x开头

# 整数类型
# 英文名 integer，简写为int，可以表示正数、负数和0
# 整数的不同表示方式
# 十进制  默认的进制
# 二进制  以0b开头
# 八进制  以0o开头
# 十六进制  以0x开头n1 =90
n2 =-76
n3 =0
print(n1,type(n1))
print(n2,type(n2))
print(n3,type(n3))# 整数可以表示为二进制，十进制，八进制，十六进制
print('十进制',118)
print('二进制',11111111,'error model')
print('二进制',0b11111111)
print('八进制',0o176)
print('十六进制',0xFFFF)

结果

90 <class 'int'>
-76 <class 'int'>
0 <class 'int'>
十进制 118
二进制 11111111 error model
二进制 255
八进制 126
十六进制 65535

5.浮点数类型

# 浮点数类型
a =3.14
print(a,type(a))
# 圆周率π
import math
b = math.pi
print(b,type(b))n1 = 1.1
n2 = 2.2
n3 = 2.1
print(n1+n2,'不正常')
print(n1 +n3,'正常')from decimal import Decimal
print(Decimal(n1)+Decimal(n2),'不正常')
print(Decimal('1.1')+Decimal('2.2'),'正常')

结果

3.14 <class 'float'>
3.141592653589793 <class 'float'>
3.3000000000000003 不正常
3.2 正常
3.300000000000000266453525910 不正常
3.3 正常

6.布尔类型

布尔类型
用来表示真或者假的值
True表示真，False表示假
布尔类型可以转化为整数
True --> 1
False -->0

# 布尔类型
# 用来表示真或者假的值
# True表示真，False表示假
# 布尔类型可以转化为整数
# True --> 1
# False -->0f1= True
f2 = False
print(f1,type(f1))
print(f2,type(f2))
print(f1+1)
print(f2+1)

结果

True <class 'bool'>
False <class 'bool'>
2
1

# 布尔运算bool
a,b=1,2
print('-'*20,'and 与运算 需要两者都为真才为真','-'*20)
print(a==1 and b==2)
print(a==1 and b<2)
print(a!=1 and b==2)
print(a!=1 and b!=2)
print()print('-'*20,'or 或运算 需要两者都为假才为假','-'*20)
print(a==1 or b==2)
print(a==1 or b<2)
print(a!=1 or b==2)
print(a!=1 or b!=2)print('-'*20,'not 非运算 取反','-'*20)
f = True
f2 = False
print(not f,'取反')
print(not f2,'取反')print('-'*20,'in 和 not in 在或者不在里面','-'*20)
s='helloworld'
print('w' in s,'表示w在s中为真')
print('k' is s,'表示k在s中为假')
print('w' not in s,'表示w不在s中为假')
print('k' not in s,'表示k不在s中为真')

# 布尔运算bool
a,b=1,2
print('-'*20,'and 与运算 需要两者都为真才为真','-'*20)
print(a==1 and b==2)
print(a==1 and b<2)
print(a!=1 and b==2)
print(a!=1 and b!=2)
print()print('-'*20,'or 或运算 需要两者都为假才为假','-'*20)
print(a==1 or b==2)
print(a==1 or b<2)
print(a!=1 or b==2)
print(a!=1 or b!=2)print('-'*20,'not 非运算 取反','-'*20)
f = True
f2 = False
print(not f,'取反')
print(not f2,'取反')print('-'*20,'in 和 not in 在或者不在里面','-'*20)
s='helloworld'
print('w' in s,'表示w在s中为真')
print('k' is s,'表示k在s中为假')
print('w' not in s,'表示w不在s中为假')
print('k' not in s,'表示k不在s中为真')

结果

-------------------- and 与运算 需要两者都为真才为真 --------------------
True
False
False
False-------------------- or 或运算 需要两者都为假才为假 --------------------
True
True
True
False
-------------------- not 非运算 取反 --------------------
False 取反
True 取反
-------------------- in 和 not in 在或者不在里面 --------------------
True 表示w在s中为真
False 表示k在s中为假
False 表示w不在s中为假
True 表示k不在s中为真进程已结束,退出代码0

7.字符串类型

字符串又被称为不可变的字符序列
可以使用单引号’’ 双引号"" 三引号’’’ ‘’’ 或者""""""来定义
单引号和双引号定义的字符串必须在一起
三引号定义的字符串可以分布在连续的多行

# 字符串类型
# 字符串又被称为不可变的字符序列
# 可以使用单引号''   双引号""   三引号''' ''' 或者""""""来定义
# 单引号和双引号定义的字符串必须在一起
# 三引号定义的字符串可以分布在连续的多行str1 = '人生苦短，我用python'#只能在一行使用，单引号
str2 = "人生苦短，我用python"
str3 = """人生苦短，
我用python"""
str4 = '''人生苦短，
我用python'''
print(str1,type(str1))
print(str2,type(str2))
print(str3,type(str3))
print(str4,type(str4))

结果

人生苦短，我用python <class 'str'>
人生苦短，我用python <class 'str'>
人生苦短，
我用python <class 'str'>
人生苦短，
我用python <class 'str'>

8.数据类型转换

# 数据类型转换
name = '张三'
age= 20print(type(name),type(age)) # 说明name与age的数据类型不相同
# print('我叫'+name+'今年'+age+'岁') 当将str与int类型进行连接时，报错，解决方案，类型转换
print('我叫'+name+'今年'+str(age)+'岁','\n当将str与int类型进行连接时，报错，解决方案，类型转换')# 将其他类型转换成str
print('-'*20,'str()将其他类型转化为str类型','-'*20)
a=10
b=198.8
c=False
print(type(a),type(b),type(c),"原来字符串类型")print(str(a),str(b),str(c),'将其他字符串类型转换为str类型')
print(type(a),type(b),type(c),'为什么这里没有转换成功还是原来的类型？因为a,b,c的数据类型是原始数据类型')
print(str(a),str(b),str(c),type(str(a)),type(str(b)),type(str(c)),'需要操作在同一命令行下，通过转换数据类型为str')print('-'*20,'int()将其他的数据类型转换为int类型','-'*20)
s1='128'
f1=98.7
s2='77.77'
f2=True
s3='hello'
print(type(s1),type(f1),type(s2),type(f2),type(s3))
print(int(s1),type(int(s1)),'将字符串类型转化为整数型(int)')
print(int(f1),type(int(f1)),'这里不能用type(f1)，这样的话还是float类型数据','float转成int类型截取整数部分，舍弃小数部分')
#print(int(s1),type(int(s2)))字符串型小数不能直接转成Int类型
print(int(float(s2)),type(int(float(s2))),'先将字符串类型转成浮点型，再将浮点型转换为int类型')
print(int(f2),type(int(f2)))
#print(int(s3),type(int(s3)),'将str转换为int类型时，字符串必须为数字串（整数），非数字串是不允许转换的')print('-'*20,'float()函数将其他类型数据转换成float类型','-'*20)
s11='128.22'
s22='76'
f22=True
s33='hello'
i=98
print(type(s11),type(s22),type(f22),type(s33),type(i),'输出原来的字符串类型')
print(float(s11),type(float(s11)),'字符串类型的浮点数转为浮点数')
print(float(s22),type(float(s22)),'字符串类型的整数转换为浮点数')
print(float(f22),type(float(f22)),'布尔类型转换为浮点型')
# print(float(s33),type(float(s33)),'字符串类型不能转换为浮点型')
print(float(i),type(float(i)),'整数类型转换为浮点型')

结果

<class 'str'> <class 'int'>
我叫张三今年20岁
当将str与int类型进行连接时，报错，解决方案，类型转换
-------------------- str()将其他类型转化为str类型 --------------------
<class 'int'> <class 'float'> <class 'bool'> 原来字符串类型
10 198.8 False 将其他字符串类型转换为str类型
<class 'int'> <class 'float'> <class 'bool'> 为什么这里没有转换成功还是原来的类型？因为a,b,c的数据类型是原始数据类型
10 198.8 False <class 'str'> <class 'str'> <class 'str'> 需要操作在同一命令行下，通过转换数据类型为str
-------------------- int()将其他的数据类型转换为int类型 --------------------
<class 'str'> <class 'float'> <class 'str'> <class 'bool'> <class 'str'>
128 <class 'int'> 将字符串类型转化为整数型(int)
98 <class 'int'> 这里不能用type(f1)，这样的话还是float类型数据 float转成int类型截取整数部分，舍弃小数部分
77 <class 'int'> 先将字符串类型转成浮点型，再将浮点型转换为int类型
1 <class 'int'>
-------------------- float()函数将其他类型数据转换成float类型 --------------------
<class 'str'> <class 'str'> <class 'bool'> <class 'str'> <class 'int'> 输出原来的字符串类型
128.22 <class 'float'> 字符串类型的浮点数转为浮点数
76.0 <class 'float'> 字符串类型的整数转换为浮点数
1.0 <class 'float'> 布尔类型转换为浮点型
98.0 <class 'float'> 整数类型转换为浮点型

9.注释功能

在代码中对代码的功能进行解释性说明的注释性文字，可以提高代码的可读性
注释的内容会被Python解释权忽略
通常包括三种类型的注释
单行注释 -->以“#”开头，直到换行结束
多行注释 -->并没有单独的多行注释标记，将一堆三引号之间的代码成为多行注释
中文编码声明注释 ——>在文件开头加上中文声明注释，用以指定源码文件的编码格式
快捷键：ctrl+?
单行注释

#在代码中对代码的功能进行解释性说明的注释性文字，可以提高代码的可读性
# 注释的内容会被Python解释权忽略
# 通常包括三种类型的注释
# 单行注释 -->以“#”开头，直到换行结束
# 多行注释 -->并没有单独的多行注释标记，将一堆三引号之间的代码成为多行注释
# 中文编码声明注释 ——>在文件开头加上中文声明注释，用以指定源码文件的编码格式
# 快捷键：ctrl+?
# 单行注释
# print('hello')'''多行
注释'''
print('在代码的第一行输入    #coding:gbk,可以将默认的utf-8的格式转为ANSI格式')
print('中文的编码方式写在代码的第一行，声明代码格式，编码声明')

结果

在代码的第一行输入    #coding:gbk,可以将默认的utf-8的格式转为ANSI格式
中文的编码方式写在代码的第一行，声明代码格式，编码声明

10.标识符和保留字

python标识符和保留字
保留字在给对象取名字的时候都不能用

#python标识符和保留字
# 保留字在给对象取名字的时候都不能用
import keyword
print(keyword.kwlist )
print('这些关键字不能作为变量名使用，会报错 ')
# 变量、函数、类、模块和其他对象起的名字就叫标识符
# 规则：
# 字母、数字、下划线....
# 不能以数字开头
# 不能使用保留字
# 严格区分大小写

结果

['False', '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', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
这些关键字不能作为变量名使用，会报错

11.input输入

# 输出函数
present = input('想要什么礼物：')
print(present,type(present))

12.从键盘录入两个整数，计算两个整数的和

a= input('请输入第一个数：')
b=input('请输入第二个数：')
print(type(a),type(b),'这里可以看到a和b都是字符串而不是整数类型')print(a+b,'这里的a+b是连接作用，而不是加法，需要对类型进行转换')
print(int(a)+int(b),'这里对字符类型进行转换后就可以进行加减')# 或者这样更简单
c=int(input('请输入第三个数：'))
d=int(input('请输入第四个数：'))
print(c+d)

结果

请输入第一个数：11
请输入第二个数：12
<class 'str'> <class 'str'> 这里可以看到a和b都是字符串而不是整数类型
1112 这里的a+b是连接作用，而不是加法，需要对类型进行转换
23 这里对字符类型进行转换后就可以进行加减
请输入第三个数：11
请输入第四个数：12
23

13.运算符

# python中常用的运算符
# 算数运算符   标准算数运算符、取余运算符、幂运算符
# 赋值运算符
# 比较运算符
# 布尔运算符
# 位运算符# 标准算数运算符
print(1+1,'加法运算a+b')
print(1-1,'减法运算a-b')
print(2*4,'乘法运算a*b')
print(11/2,'除法运算a/b')
print(11//2,'整除运算a//b')
print(11%2,'取余运算a/b的余数')
print(2**3,'次方运算a^b')

结果

2 加法运算a+b
0 减法运算a-b
8 乘法运算a*b
5.5 除法运算a/b
5 整除运算a//b
1 取余运算a/b的余数
8 次方运算a^b

print(9//4)
print(-9//-4)print(9//-4,'一正一负的整数公式，向下取整')
print(-9//4,'一正一负的整数公式，向下取整')print(9%-4,'公式  余数=被除数-除数*商，即9-(-4)*(-3)=-3')
print(-9%4,'公式  余数=被除数-除数*商，即-9-(4)*(-3)=-3')

结果

2
2
-3 一正一负的整数公式，向下取整
-3 一正一负的整数公式，向下取整
-3 公式  余数=被除数-除数*商，即9-(-4)*(-3)=-3
3 公式  余数=被除数-除数*商，即-9-(4)*(-3)=-3

14.赋值运算符

# 赋值运算符
a= 3+4
print(a)a=b=c=20    #链式赋值print(a,id(a))
print(b,id(b))
print(c,id(c))print('-'*20,'支持参数赋值','-'*20)
d=20
print(d,'输出原始的d值')
d+=30   #相当于a=a+30
print(d,'d+=30输出d=d+30')
d-=10
print(d,'d-=10,输出d=d-10')
d*=2
print(d,'d*=2输出d=d*2')
print(type(d))print('-'*20,'解包赋值','-'*20)
a,b,c=10,20,30
print(a,b,c,type(a),type(b),type(c),id(a),id(b),id(c))
# 交换前
print('交换之前：',a,b)
# 交换
a,b=b,a
print('交换之后：',a,b)

结果

7
20 140734984135680
20 140734984135680
20 140734984135680
-------------------- 支持参数赋值 --------------------
20 输出原始的d值
50 d+=30输出d=d+30
40 d-=10,输出d=d-10
80 d*=2输出d=d*2
<class 'int'>
-------------------- 解包赋值 --------------------
10 20 30 <class 'int'> <class 'int'> <class 'int'> 140734984135360 140734984135680 140734984136000
交换之前： 10 20
交换之后： 20 10

15.比较运算符

# 比较运算符
a,b=10,20
print('a>b吗？',a>b)
print('a<b吗？',a<b)
print('a>=b吗？',a>=b)
print('a<=b吗？',a<=b)
print('a==b吗？',a==b)
print('a!=b吗？',a!=b)'''
一个等号表示赋值运算符，==表示比较运算符
一个变量由三部分组成：标识，类型，值
==比较的是值还是标识呢？比较的是值
比较对象的标识使用is
'''
a=10
b=10
print(a==b,'a==b','说明a与b的value相等')
print(a is b,'a==b','说明a与b的id标识相等')lst1=[11,22,33]
lst2=[11,22,33]
print(lst1 == lst2,'表示value值相等')
print(lst1 is lst2,'表示id不相同')
print(id(lst1),id(lst2))
print(a is not b,'表示a与b的id不相等')
print(lst1 is not lst2,'表示a与b的值相等')

结果

a>b吗？ False
a<b吗？ True
a>=b吗？ False
a<=b吗？ True
a==b吗？ False
a!=b吗？ True
True a==b 说明a与b的value相等
True a==b 说明a与b的id标识相等
True 表示value值相等
False 表示id不相同
2186371158408 2186371158920
False 表示a与b的id不相等
True 表示a与b的值相等

16.位运算符

# 位运算符号
print(4&8,'二进制：4的二进制为0100,8的二进制为1000','位运算符：相同为1')
print(4|8,'或|,同为0时结果为0')
print(4<<1,'向左移动一位,相当于乘以2')
print(4<<2,'向左移动两位，相当于乘以4')print(4>>1,'向右移动一位,相当于除以2')
print(4>>2,'向右移动两位，相当于除以4')print('-'*20,'运算符的优先级：算数运算>位运算>比较运算>布尔运算>赋值运算','-'*20)
print('有括号先计算括号里的')

结果

0 二进制：4的二进制为0100,8的二进制为1000 位运算符：相同为1
12 或|,同为0时结果为0
8 向左移动一位,相当于乘以2
16 向左移动两位，相当于乘以4
2 向右移动一位,相当于除以2
1 向右移动两位，相当于除以4
-------------------- 运算符的优先级：算数运算>位运算>比较运算>布尔运算>赋值运算 --------------------
有括号先计算括号里的

17.顺序结构

# 顺序结构
print('-'*10,'程序打开','-'*10)
print('1.打开冰箱')
print('2.把大象放进冰箱')
print('3.把冰箱门关上')
print('-'*10,'程序结束','-'*10)

结果

---------- 程序打开 ----------
1.打开冰箱
2.把大象放进冰箱
3.把冰箱门关上
---------- 程序结束 ----------

18.测试对象的布尔值

# 测试对象的布尔值
print('-'*10,'以下对象的布尔值为False','-'*10)
print(bool(False))
print(bool(0))
print(bool(0.0))
print(bool(None))
print(bool(''))
print(bool(""))
print(bool([]),'空列表')
print(bool(list()),'空列表')
print(bool(()),'空元组')
print(bool(tuple()),'空元组')
print(bool({}),'空字典')
print(bool(dict()),'空字典')
print(bool(set()),'空集合')print('-'*10,'其他对象的布尔值为True','-'*10)

结果

---------- 以下对象的布尔值为False ----------
False
False
False
False
False
False
False 空列表
False 空列表
False 空元组
False 空元组
False 空字典
False 空字典
False 空集合
---------- 其他对象的布尔值为True ----------进程已结束,退出代码0

19.选择结构

# 选择结构
# 银行取钱-->双分支结构
money = 1000
s = int(input('请输入取款金额：'))
if money >=s:money = money - sprint('取款成功，余额为：',money,'元')
else:print('取款失败，请重新输入取款金额','您的总余额为',money,'元','请输入小于等于',money,'元的金额')s = int(input('请重新输入取款金额：'))money = money - sprint('取款成功，余额为：', money, '元')

结果

请输入取款金额：100
取款成功，余额为： 900 元

20.双分支结构

# 双分支结构
# 在系统录入一个整数，编写程序让计算机判断是奇数还是偶数
num = int(input('请输入一个整数：'))if num %2 == 0:print(num,'是偶数')
else:print(num,'是奇数')

结果

请输入一个整数：99
99 是奇数

21.多分支结构

# 多分支结构 多选一执行
# 录入整数成绩
print('90-100   A\n','80-89   B\n','70-79   C\n','60-69   D\n','0-59    E\n','大于100或者小于0的为非法整数')
score = int(input('请输入一个成绩：'))# 判断语句
if score>=90 and score<=100:# 或者用90<=score<=100形式print(score,'分为A')
elif score>=80 and score<=89:print(score,'分为B')
elif score>=70 and score<=79:print(score,'分为C')
elif score>=60 and score<=69:print(score,'分为D')
elif score <60 and score>=0:print(score,'分为E')
else:print('输入错误，请重新输入')

结果

90-100   A80-89   B70-79   C60-69   D0-59    E大于100或者小于0的为非法整数
请输入一个成绩：100
100 分为A

22.if嵌套

# 嵌套if
# 会员    大于等于200     8折
#     大于等于100   9折
#         不打折
# 非会员    大于等于200    9.5折
#         不打折
answer=input('您是会员吗？y/n:')
money=float(input('请输入您的购物金额：'))
if answer=='y':#会员print('会员')if money>=200:print('付款金额为：',money*0.8,'元')elif money>=100:print('付款金额为：',money*0.9,'元')else:print('不打折，付款金额为：',money,'元')
else: #非会员print('非会员')if money>=200:print('打9.5折，付款金额为：',money*0.95,'元')else:print('不打折，付款金额为：',money,'元')

结果

您是会员吗？y/n:y
请输入您的购物金额：100
会员
付款金额为： 90.0 元

23.比较两个整数大小

# 录入两个整数，比较两个整数大小
a=int(input('请输入第一个整数：'))
b=int(input('请输入第二个整数：'))# # 比较大小
# if a >=b:
#     print(a,'大于等于',b)
# else :
#     print(a,'小于',b)
#
# 使用条件表达式进行比较
print(  str(a)+'大于等于'+str(b)     if a>=b else    str(a)+'小于'+str(b))
print('这个与上面的是相同的，条件表达式简化操作')

结果

请输入第一个整数：22
请输入第二个整数：25
22小于25
这个与上面的是相同的，条件表达式简化操作

24.占位符pass

# pass语句，一个占位符，用到需要写语句的地方
answer = input('您是会员吗？y/n:')# 判断是否为会员
if answer=='y':pass
else:pass

结果

您是会员吗？y/n:y进程已结束,退出代码0

25.range三种创建方式

# range()三种创建方式
print('range(stop),     创建一个[0,stop)之间的整数序列，步长为1')
print('rang(start,stop),    创建一个[start,stop)之间的整数序列，步长为1')
print('rang(start,stop,step),   创建一个[start,stop)之间的整数序列，步长为step')
print()
print('-'*20,'range(a)，表示从0到a，不包括a，步长为1','-'*20)
r=range(10)
print(r)
print(list(r),'默认从0开始，步长为1')
print('-'*20,'range(a,b)，表示从a到b,不包括b，步长为1','-'*20)
r=range(1,10)
print(list(r))
print('-'*20,'range(a,b,c)，表示从a到b,不包括b,步长为c','-'*20)
r=range(1,10,2)
print(list(r))
print('-'*20,'判断指定的整数在序列中是否存在 in 或者not in','-'*20)
print(10 in r)
print(9 in r)
print(10 not in r)
print(9 not in r)
print('range（）类型的优点：不管range对象表示的整数序列有多长，所有的range对象占用的内存空间都是相同的，因为仅仅需要存储start，stop和step，只有当用到range对象时，才会计算序列中的相关元素')

结果

range(stop),     创建一个[0,stop)之间的整数序列，步长为1
rang(start,stop),    创建一个[start,stop)之间的整数序列，步长为1
rang(start,stop,step),   创建一个[start,stop)之间的整数序列，步长为step-------------------- range(a)，表示从0到a，不包括a，步长为1 --------------------
range(0, 10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 默认从0开始，步长为1
-------------------- range(a,b)，表示从a到b,不包括b，步长为1 --------------------
[1, 2, 3, 4, 5, 6, 7, 8, 9]
-------------------- range(a,b,c)，表示从a到b,不包括b,步长为c --------------------
[1, 3, 5, 7, 9]
-------------------- 判断指定的整数在序列中是否存在 in 或者not in --------------------
False
True
True
False
range（）类型的优点：不管range对象表示的整数序列有多长，所有的range对象占用的内存空间都是相同的，因为仅仅需要存储start，stop和step，只有当用到range对象时，才会计算序列中的相关元素进程已结束,退出代码0

26.while循环结构

# 4步循环法
# 1.初始化变量
# 2.条件判断
# 3.条件执行体
# 4.改变变量
# 总结：初始化变量与条件判断的变量与改变的变量为同一个
sum=0#用于存储累加和
a = 0
# 条件变量
while a<1000:# 条件执行体sum+=a# 改变变量a+=1
print('和为',sum)

结果

和为 499500进程已结束,退出代码0

# 循环结构
print('循环的分类:while循环、for-in循环语句')print('while循环')
# 初始化值
a=1
# 判断条件表达式
# if a<10:
while a<=10:# 执行条件执行体print(a)a+=1
print('选择结构的if与循环结构while的区别：if是判断一次，条件为True执行一次。while是判断N+1次，条件为True执行N次')

结果

循环的分类:while循环、for-in循环语句
while循环
1
2
3
4
5
6
7
8
9
10
选择结构的if与循环结构while的区别：if是判断一次，条件为True执行一次。while是判断N+1次，条件为True执行N次进程已结束,退出代码0

# 计算1到100之间的偶数和
sum=0
a=1
while a<=100:# if a%2==0:if not a%2:sum+=aa+=1
print('1-100之间的偶数和为',sum)while a<=100:# if a%2==1:if a%2:sum+=aa+=1
print('1-100之间的奇数和为',sum)

1-100之间的偶数和为 2550
1-100之间的奇数和为 2550进程已结束,退出代码0

27.for-in循环

# for-in循环
# In表达从（字符串、序列等）中一次取值，又称为遍历
# for-in遍历的对象必须是可迭代对象
# for - in的语法结构
# for 自定义的变量 in 可迭代对象：# 循环体for item in 'python':print(item)# range()产生一个整数序列，也是一个可迭代对象
for i in range(10):print(i)# 循环不需要使用到自定义变量，可以将自定义用_表示
for _ in range(5):print('python')print('-'*20,'使用for循环，计算1到100之间的偶数和','-'*20)
sum=0
for item in range(1,101):# if item %2==0:与下面结果一样# if item%2:if not item%2:sum+=itemprint('1到100之间的偶数和为',sum)

结果

p
y
t
h
o
n
0
1
2
3
4
5
6
7
8
9
python
python
python
python
python
-------------------- 使用for循环，计算1到100之间的偶数和 --------------------
1到100之间的偶数和为 2550进程已结束,退出代码0

28.水仙花数

'''输出100到999之间的水仙花数
举例：153=3*3*3+5*5*5+1*1*1'''for item in range(100,1000):ge=item%10 #得到个位上的数字shi=item//10%10 #得到10位上的数字bai=item//100 #得到百位上的数字# print(bai,shi,ge)if item == ge**3 +shi**3+bai**3:print(item)

结果

153
370
371
407进程已结束,退出代码0

29.break流程控制语句

# 流程控制语句break
print('break语句：用于结束循环结构，通常与分支结构if进行使用')print('从键盘录入密码，最多录入三次，如果正确就结束循环')for item in range(3):pwd=input('请输入密码：')if pwd=='8888':print('密码正确')breakelse:print('密码不正确，请重新输入')

结果

break语句：用于结束循环结构，通常与分支结构if进行使用
从键盘录入密码，最多录入三次，如果正确就结束循环
请输入密码：1111
密码不正确，请重新输入
请输入密码：1111
密码不正确，请重新输入
请输入密码：1111
密码不正确，请重新输入进程已结束,退出代码0

while循环

a=0
while a<3:pwd=input('请输入密码：')if pwd=='8888':print('密码正确')breakelse:print('密码不正确')a+=1

结果

请输入密码：00.
密码不正确
请输入密码：00
密码不正确
请输入密码：222
密码不正确进程已结束,退出代码0

for item in range(3):pwd=input('请输入密码：')if pwd=='8888':print('密码正确')breakelse:print('密码错误，请重新输入')
else:print('对不起，三次密码均错误')

结果

请输入密码：66366
密码错误，请重新输入
请输入密码：2223
密码错误，请重新输入
请输入密码：223
密码错误，请重新输入
对不起，三次密码均错误进程已结束,退出代码0

a=1
while a<=3:pwd=input('请输入密码：')print(type(pwd),id(pwd))if pwd=='8888':print('密码正确')breakelse:print('密码不正确')# 改变变量a+=1
else:print('对不起，三次密码均输入错误')

结果

请输入密码：1112
<class 'str'> 1876250580656
密码不正确
请输入密码：454445
<class 'str'> 1876244750640
密码不正确
请输入密码：1112
<class 'str'> 1876250581168
密码不正确
对不起，三次密码均输入错误进程已结束,退出代码0

30.九九乘法表

# 输出一个三行四列的矩阵
for i in range(1,4):for j in range(1,5):print(i,'*',j,'=',i*j,end='\t') # 不换行输出print()

1 * 1 = 1   1 * 2 = 2  1 * 3 = 3  1 * 4 = 4
2 * 1 = 2  2 * 2 = 4  2 * 3 = 6  2 * 4 = 8
3 * 1 = 3  3 * 2 = 6  3 * 3 = 9  3 * 4 = 12 进程已结束,退出代码0

# 输出一个九九乘法表
for i in range(1,10):for j in range(1,i+1):print(i,'*',j,'=',i*j,end='\t')print()

结果

1 * 1 = 1
2 * 1 = 2  2 * 2 = 4
3 * 1 = 3  3 * 2 = 6  3 * 3 = 9
4 * 1 = 4  4 * 2 = 8  4 * 3 = 12 4 * 4 = 16
5 * 1 = 5  5 * 2 = 10 5 * 3 = 15 5 * 4 = 20 5 * 5 = 25
6 * 1 = 6  6 * 2 = 12 6 * 3 = 18 6 * 4 = 24 6 * 5 = 30 6 * 6 = 36
7 * 1 = 7  7 * 2 = 14 7 * 3 = 21 7 * 4 = 28 7 * 5 = 35 7 * 6 = 42 7 * 7 = 49
8 * 1 = 8  8 * 2 = 16 8 * 3 = 24 8 * 4 = 32 8 * 5 = 40 8 * 6 = 48 8 * 7 = 56 8 * 8 = 64
9 * 1 = 9  9 * 2 = 18 9 * 3 = 27 9 * 4 = 36 9 * 5 = 45 9 * 6 = 54 9 * 7 = 63 9 * 8 = 72 9 * 9 = 81 进程已结束,退出代码0

31. 流程控制语句break与contine在二重循环中的使用

# 流程控制语句break与contine在二重循环中的使用
for i in range(5):for j in range(1,11):if j%2==0:# breakcontinueprint(j,end='\t')print()

结果

1    3   5   7   9
1   3   5   7   9
1   3   5   7   9
1   3   5   7   9
1   3   5   7   9   进程已结束,退出代码0

32.列表list

a=10
lst=['hello','world',98]
print(id(lst))
print(type(lst))
print(lst)

结果

2669856313736
<class 'list'>
['hello', 'world', 98]进程已结束,退出代码0

lst=['hello','world','98']
# 创建列表的两种方式，使用内置函数list()
lst2=list(['hello','world',98])
print(lst)
print(lst2)
print(lst[0],'索引值从0开始')
print(lst[-1],'最后一个索引值是-1，同理可推理其他数据')

结果

['hello', 'world', '98']
['hello', 'world', 98]
hello 索引值从0开始
98 最后一个索引值是-1，同理可推理其他数据进程已结束,退出代码0

33.index索引

lst=['hello','world',98,'hello','123']
print(lst.index('hello'),'如果列表中有相同元素，只返回相同元素中的第一个')
# print(lst.index('python'))
print(lst.index('hello',1,4),'表示在索引1到4之间查找是否包含hello')
print(lst.index(98))
print(lst[2],'获取索引为2的元素')
print(lst[-3],'获取索引为-3的元素')
print('索引不在范围内会报错')

结果

0 如果列表中有相同元素，只返回相同元素中的第一个
3 表示在索引1到4之间查找是否包含hello
2
98 获取索引为2的元素
98 获取索引为-3的元素
索引不在范围内会报错进程已结束,退出代码0

34.in 或not in

print('p' in 'python')
print('k' not in 'python')lst=[10,20,'python','hello']
print(10 in lst)
print(10 not in lst)
print('依次打印列表中的索引值')
for item in lst:print(item)

结果

True
True
True
False
依次打印列表中的索引值
10
20
python
hello进程已结束,退出代码0

35.append、extend、insert列表添加元素

print()
print('向列表添加一个元素')
lst=[10,20,30]
print('添加元素之前',lst,id(lst))
lst.append(100)
print('添加元素之后',lst,id(lst))
lst2=['hello','world']
lst.append(lst2)
print(lst,'append表示添加为一个数组')
lst3=[123,456]
lst.extend(lst3)
print(lst,'extend在列表后面依次添加元素')
lst.insert(1,90)
print(lst,'表示在任意位置添加一个元素')

向列表添加一个元素
添加元素之前 [10, 20, 30] 2689590120840
添加元素之后 [10, 20, 30, 100] 2689590120840
[10, 20, 30, 100, ['hello', 'world']] append表示添加为一个数组
[10, 20, 30, 100, ['hello', 'world'], 123, 456] extend在列表后面依次添加元素
[10, 90, 20, 30, 100, ['hello', 'world'], 123, 456] 表示在任意位置添加一个元素进程已结束,退出代码0

36.remove、pop、clear、del删除元素

print('remove使用')
lst=[10,20,30,40,50,30,60]
lst.remove(30)
print(lst,'从列表中移除一个元素，如果有重复元素只移除第一个元素')
# lst.remove(100)
lst.pop(1)
print(lst,'移除元素中第一个元素位置的索引')print('-'*20,'切片操作，删除至少一个元素，将产生一个新的列表对象','-'*20)
new_list=lst[1:3]
print('原列表',lst)
print('切片后的列表',new_list)lst[1:3]=[]
print(lst,'不产生新的列表对象，而是删除愿列表中的内容')
lst.clear()
print(lst,'清除列表中的所有元素')del lst
print(lst,'清除列表对象')

结果

Traceback (most recent call last):File "C:/Users/PC/Desktop/pycode/代码/马士兵-人工智能python基础/chap6/demo7.py", line 26, in <module>print(lst,'清除列表对象')
NameError: name 'lst' is not defined
remove使用
[10, 20, 40, 50, 30, 60] 从列表中移除一个元素，如果有重复元素只移除第一个元素
[10, 40, 50, 30, 60] 移除元素中第一个元素位置的索引
-------------------- 切片操作，删除至少一个元素，将产生一个新的列表对象 --------------------
原列表 [10, 40, 50, 30, 60]
切片后的列表 [40, 50]
[10, 30, 60] 不产生新的列表对象，而是删除愿列表中的内容
[] 清除列表中的所有元素进程已结束,退出代码1

37.sort、reverse排序

print('列表元素的排序操作')
lst=[20,40,30,10,20]
print('排序前的列表',lst,id(lst))
lst.sort()
print('排序后的列表',lst,id(lst),'sort表示按升序排序')
lst.sort(reverse=True)
print(lst,'reverse=True表示列表按降序排序')print('-'*20,'使用内置函数sorted()对列表进行排序，将产生一个新的列表对象','-'*20)
print(lst)
new_list=sorted(lst)
print(lst)
print(new_list,'sort是对原有列表进行排序操作,sorted表示产生新列表进行排序操作，不影响原列表')
desc_list=sorted(lst,reverse=True)
print(desc_list)

结果

列表元素的排序操作
排序前的列表 [20, 40, 30, 10, 20] 1598529687944
排序后的列表 [10, 20, 20, 30, 40] 1598529687944 sort表示按升序排序
[40, 30, 20, 20, 10] reverse=True表示列表按降序排序
-------------------- 使用内置函数sorted()对列表进行排序，将产生一个新的列表对象 --------------------
[40, 30, 20, 20, 10]
[40, 30, 20, 20, 10]
[10, 20, 20, 30, 40] sort是对原有列表进行排序操作,sorted表示产生新列表进行排序操作，不影响原列表
[40, 30, 20, 20, 10]进程已结束,退出代码0

lst=[i*i for i in range(1,10)]
print(lst)print('列表中的元素的值为2,4,6,8,10')
lst2=[i*2 for i in range(1,6)]
print(lst2)

结果

[1, 4, 9, 16, 25, 36, 49, 64, 81]
列表中的元素的值为2,4,6,8,10
[2, 4, 6, 8, 10]进程已结束,退出代码0

python基础教程--代码集合（上）相关推荐

1. python基础教程--代码集合（下）

   文章目录 38.字典dict 38.1 创建字典 38.2 字典获取元素 38.3 key字典 38.4key-value-items键值对 38.5字典的遍历 38.6 哈希函数haxi 39.可变 ...

2. python基础教程代码-Python基础教程代码怎么是英文 看不懂啊？

   很抱歉,目前几乎所有编程语言用的都是英文. 但学编程和学英文是两码事,编程语言所需要的英文,一个翻译软件就足够了. 比如说,abcdefg会数吧? 变量名可以用这些来标识,你用拼音也行,看得懂就好. ...

3. Python基础教程书籍案例：新闻采集(新闻聚合)【上】

   这个练习项目来自<Python基础教程(第2版)>,案例原名为"新闻聚合". 项目分为两个阶段: 第一阶段:通过与NNTP服务器进行交互获取新闻源. 第二阶段:获取不同 ...

4. python基础教程书籍推荐-初学者python入门必看书籍推荐（上）

   随着最近Python的热度上涨,学习的人数也在增多,也因为Python这门语言的简短.易学.语言优美的优点,吸引了很多人来学习它.初学者想要入门,就必须先通过阅读,学习大量的理论知识对Python有一 ...

5. python基础教程第三版-《Python基础教程第三版》原版中英文PDF+代码+袁国忠(译)...

   <Python基础教程第3版>整本书的结构安排还是比较明显的.先是基础知识和python的基本数据类型和语言特性介绍,然后是面向对象的编程.之后介绍python的标准库以及相关主题的编程( ...

6. python基础教程第二版答案-《Python基础教程》（第2版修订版）中要注意的地方...

   想必现在大家学习Python都会用3.0及以上的版本了,虽然2.X的版本依然很多,但是这两年随着部分开源项目不再支持2.X版本,3.X已经成为趋势. 正是在这样的大背景下,我最近用这本<Pyth ...

7. python基础教程第二版和第三版有什么区别-《Python基础教程》（第2版修订版）中要注意的地方...

   想必现在大家学习Python都会用3.0及以上的版本了,虽然2.X的版本依然很多,但是这两年随着部分开源项目不再支持2.X版本,3.X已经成为趋势. 正是在这样的大背景下,我最近用这本<Pyth ...

8. python黑马教程ppt_,python基础教程 PPT

   python基础教程 PPT Python我这里有Python编开发,进阶,化,实战等系列视频教程,还有安装包,素材,代码内容,这里就不一一说了,全套内容一共300G左右,非常的详细,需要的请到网盘下 ...

9. 视频教程-快速入门Python基础教程_Python基础知识大全-Python

   快速入门Python基础教程_Python基础知识大全 十余年计算机技术领域从业经验,在中国电信.盛大游戏等多家五百强企业任职技术开发指导顾问,国内IT技术发展奠基人之一. 杨千锋 ¥99.00 立即 ...

最新文章

1. Python 之 Pandas (二)选择数据
2. 开源纯C#轻量级数据库引擎：SharpHSQL 1.0.3.0版本
3. Java 获取链表的元素
4. java生成unix.z压缩_JAVA压缩 解压缩zip 并解决linux下中文乱码
5. C++ 实现简易 log 日志系统
6. python怎么把代码做成软件_python代码能做成软件吗
7. ie visio 打开_Visio viewer 不能从IE打开vsd文件
8. 可用计算机处理的多种信息载体的统称,广西壮族自治区2019-2020学年语文四年级下册第二单元测试卷B卷（6页）-原创力文档...
9. NAT 穿透的几种方式
10. android系统应用更改内存,安卓root后必备神器：修改系统/清理内存神器
11. PayPal集成标准版案例（asp.net）关键源码
12. COGS 336 Vijos 1018 NOI2003 智破连环阵
13. 韩国创业公司Hdac试图通过区块链保障物联网未来
14. Python处理2个表格。从源表格中筛选符合条件的数据，写入到dst表格中
15. 百度盈利模式的弱点在哪里
16. image jpeg
17. android 字符串转小数点,Android实现计算器（计算表达式/计算小数点以及括号）...
18. 各大IT公司的名字由来(r7笔记第89天)
19. 雷人雷语的宅男同事经典语录！
20. 厦门工程技术人员职称申报操作笔记 01 继续教育学时

热门文章

1. poco c++ 开发指南_掌握这个框架，你将会开发通杀全平台的万能爬虫
2. 南京大学计算机科学系照片,欧拉图-南京大学计算机科学与技术系.pdf
3. python爬取股票大单历史记录_利用bs4爬取股票的历史交易数据
4. Android开发之自定义AlertDialog的大小
5. 将mysql从服务器永远变为只读_将mysql从服务器永远变为只读
6. 【译】Effective TensorFlow Chapter10——在TensorFlow中利用多GPU处理并行数据
7. 正确使用stl map的erase方法
8. Java编程——服务器设计方案之应用限流
9. 中国电信与华为签物联网合作协议
10. 最佳实践：如何基于MNS和OSS实现无大小限制的消息传输