Python是TIOBE编程语言排行榜排名第一的编程语言 。
python是一种解释性、交互式、面向对象的跨平台的语言。
python设计者及名称由来
Guido van Rossum 荷兰人---吉多·范罗苏姆，是 Python 编程语言的最初设计者，在 Python 社区一直担当终身仁慈独裁者（BDFL）的角色。2018 年 7 月12 日，他宣布不再担任 Python 社区的 BDFL，但后来再度被选入成为五位委员会成员之一。
-
1989 年创立了 Python 语言
-
1991年初公布了 Python 第一个公开发行版；
-
Python2 2020年官方停止升级更新。
Python3 目前主流。
python名称由来
本语言的命名源自 BBC 的 “Monty Python 飞行马戏团”，与爬行动物无关（Python 原义为“蟒蛇”）。
python特点
Python语言：简单、优雅、明确的语言。
1. 解释型语言：源代码一行一行的被解释器执行。（这些都是解释型语言：
-
JS\Shell\Python\PHP）
【补充：
解释型语言对应的是编译型语言，将源代码转换成二进制然后由CPU执行。C\C++\Go】
2.强类型语言：数据是必须要有类型的。 赋值时，自动判断数据的类型
【强类型语言：C/C++/Java/Go/Python】
【强类型语言 对应的是 弱类型语言，数据的类型是可以自动转换，不固定。例如：Shell\JS】
3.扩展性强：“胶水语言”，支持其他语言编写的模块。人工智能的算法大部分使用C++实现，Python通过调用模块实现强大的功能。
4. 支持命令式编程、结构式编程、面向对象编程、函数式编程。
python开发工具
常见的python开发工具有：
1.PyCharm: python脚本、pythonWeb开发、python爬虫。
【分为社区版和企业版】
社区版：
Communtity ....
企业版：
Professional .....
2.VScode：轻量级，需要安装各种插件；
3.Jupyter node:网页版开发环境，数据分析、人工智能、数据可视化；
python应用场景
-
web开发；
-
自动化运维
-
数据分析
-
网络爬虫
-
AI
-
自动化办公
-
自动化测试
-
科学计算
python数据类型
基本数据类型
整数 int：
print(666)
浮点数 float:
浮点数（小数）运算是不精确的；
print(0.1+0.2)
输出结果：
0.30000000000000004
字符串 str:
三种写法：
1）单引号；2）双引号；3）三引号；为了书写方便，不需要转义；
布尔 boolean:
【True真 ； False假】
空类型 none：
复合数据类型
| 名称 | 写法 | 特点 | 用法 |
|---|---|---|---|
| 列表list | [1,2,3,4] | 有序、可变、可嵌套、异构（数据类型不限） | 存放有序的临时数据 |
| 元组tuple | (1,2,3,4) | 有序（可以用下标，）、不可变、可嵌套（一般嵌套元组,建议嵌套不可变数据类型：数字、字符串、元组） | 函数的返回值和参数 |
| 字典dic | {‘a’:1,’b’:2} | 无序，可变（可以增删改查），key(不可变数据类型，不能重复)，value(任意数据类型）、键值对； | 用于：需要查询速度快的数据，一般用于做json解析 |
| 集合set | {1，2，3，4，5} | 无序、可变、不可嵌套（一般不嵌套，只能嵌套元组）、数据不能重复、数据类型只能是不可变数据类型，它的元素就是字典中的key;【交集、并集、差集】 | 去重，简单的数据集合 |
列表 list:
列表list【有序的集合，可重复】：
可以增删改查
增：append() 追加一个元素
extend() 合并一个数列
增append /extend /insert
例1：extend 在结尾追加一个数列
lis =[] lis.append(1) lis.append(2) lis.extend(['a','b','c','d']) print(lis)
结果：
[1, 2, 'a', 'b', 'c', 'd']
例2：append 在结尾追加一个元素
lis =[] lis.append(1) lis.append(2) lis.append(['a','b','c','d']) print(lis)
结果：
[1, 2, ['a', 'b', 'c', 'd']]
例3：insert 通过下标在任意地方添加数字
lis =[] lis.append(1) lis.append(2) lis.append(['a','b','c','d']) lis[1] = 5 lis[:2] = ['q','w','e'] lis.insert(0,1) print(lis)
结果：
[1, 'q', 'w', 'e', ['a', 'b', 'c', 'd']]
下标---改
[ 通过下标 改一个元素 ]
lis =[]， 空列表，像里面追加元素；
lis[1] = 5将，下标为1的元素2改为5；
lis =[] lis.append(1) lis.append(2) lis.append(['a','b','c','d']) lis[1] = 5 print(lis) #打印结果
结果：
[1, 5, ['a', 'b', 'c', 'd']]
lis[:2] = ['q','w','e'] #将下标0：2的元素改为 ['q','w','e']
print(lis)
['q', 'w', 'e', ['a', 'b', 'c', 'd']]
index查
#index(value) -> index 返回是个下标
print(lis.index('A'))
count 查看次数
print(lis.count(‘4’))
例：
lis=['1','2','3','4','5','6','4','2','6']
print(lis.count('6'))
结果：
2
pop删/del
弹出一个数： pop
【可以实现手动的垃圾回收】
删除一个数：del lis[-1]
lis =[] lis.append(1) lis.append(2) lis.append(['a','b','c','d']) lis[1] = 5 del lis[-1] #删除最后一个（组）元素 print(lis)
结果：
[1, 5]
删除一个范围：del lis[:1],即删除下标为0的元素，不包括下标为1的元素；
lis =[] lis.append(1) lis.append(2) lis.append(['a','b','c','d']) lis[1] = 5 del lis[:1] print(lis)
[5, ['a', 'b', 'c', 'd']]
正向索引
有序的数据集合，通过下标取值，从0开始。列表索引，从0开始；正向索引0 ,1, 2, 3 …..
例1：
names = ["张三"，“李四”，“王五”，"张三"，“李四”]
print(f'names={names},type(names)={type(names)}')
反向索引
例2 :反向索引 -1 ，-2 ，-3……
#!/usr/bin/python3 list = ['red', 'green', 'blue', 'yellow', 'white', 'black'] print( list[-1] ) print( list[-2] ) print( list[-3] )
black white yellow
拼接列表
>>> squares = [1, 4, 9, 16, 25] >>> squares += [36, 49, 64, 81, 100] >>> squares [1, 4, 9, 16, 25, 36, 49, 64, 81, 100] >>>
切片 步长[0:2:2]
步长【隔几个数取值；】
例：步长为2：隔两个数；步长为1：隔一个数；
取前5个值，[0:5]
每隔一个数，取前5个，[0:5:1]
#截取前两个字符 s = ["hello", "world","hahaha","!"] print (s[0:2])
#输出结果： ['hello', 'world'] 进程已结束，退出代码为 0
例2：s[-2], 截取倒数第二个字符
s = ["hello", "world","hahaha","!","a","b","c"] print (s[-2])
#输出结果 b
例3：截取从开头到 倒数第二个数字
s = ["hello", "world","hahaha","!","a","b","c"] print (s[:-2])
输出结果
['hello', 'world', 'hahaha', '!', 'a']
例4：
for i in range (1,6):
print((" * " * i).center(20))
* * * * * * * * * * * * * * *
元组 tuple:
元组：有序不可变的数据类型；【元组是不可变的列表,没有增删改的功能】
将列表的[ ]中括号换为小括号（）；
names = ("张三","李四","王五","张三","李四")
print(f' names={names}, type(names)= {type(names)}' )
字典 dictionary:
字典：通过键值对，存放，读取数值；通过键来取值速度非常快；
字典是另一种可变容器模型，且可存储任意类型对象。
字典的每个键值 key=>value 对用冒号 : 分割，每个对之间用逗号 ，分割，整个字典包括在花括号 {} 中 ,格式如下所示：
{键：值；键：值；}
d = {key1 : value1, key2 : value2, key3 : value3 }
获取字典长度
dic= { 'Name': 'Runoob', 'Age': 7, 'Class': 'First' }
print( len(dic) )
结果：
3
进程已结束，退出代码为 0
获取键、值
循环依次罗列键：
dic= {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
for key in dic:
print(key) #打印键
获取键值对
方法一【打印所有的键值】： print (dic)
dic= {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
print(dic)
结果：
{'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
进程已结束，退出代码为 0
方法二：print (dic['Age'])
dic= {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
print(dic['Age'])
结果：
7
进程已结束，退出代码为 0
方法三：print(dic.get('Age'))
dic= {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
print(dic.get('Age'))
增加值 名[‘键’] = “值”
dic['address']= "shanxi"
dic= {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
# print(len(dic))
# for key in dic:
dic['address']= "shanxi"
print(dic)
结果：
{'Name': 'Runoob', 'Age': 7, 'Class': 'First', 'address': 'shanxi'}
进程已结束，退出代码为 0
删除操作 del
dic= {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
# print(len(dic))
# for key in dic:
dic['address']= "shanxi"
del dic['Name']
print(dic)
结果：
{'Age': 7, 'Class': 'First', 'address': 'shanxi'}
进程已结束，退出代码为 0
集合 set:
略
python函数
什么是函数？
函数：一段具有特定功能的代码块。
函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。
函数能提高应用的模块性，和代码的重复利用率。你已经知道Python提供了许多内建函数，比如print()。但你也可以自己创建函数，这被叫做用户自定义函数。
定义函数
Python 中使用def语句创建函数，其一般的格式如下所示：
def line( ):
【四部分构成：
1.关键词def ；
2.line 变量名；
3.（）没有参数时也要有小括号；
4. ：不要忘记冒号结尾；
实例：
def repeator(s, n):
result = s * n
print(result)
print(type(repeator))
调用函数：
repeator('嗷', 3)
结果：
# 嗷嗷嗷
python内置函数
| 函数 | 描述 |
|---|---|
| abs() | 返回数的绝对值 |
| all() | 如果可迭代对象中的所有项均为 true，则返回 True。 |
| any() | 如果可迭代对象中的任何项为 true，则返回 True。 |
| ascii() | 返回对象的可读版本。用转义字符替换 none-ascii 字符。 |
| bin() | 返回数的二进制版本。 |
| bool() | 返回指定对象的布尔值。 |
| bytearray() | 返回字节数组。 |
| bytes() | 返回字节对象。 |
| callable() | 如果指定的对象是可调用的，则返回 True，否则返回 False。 |
| chr() | 返回指定 Unicode 代码中的字符。 |
| classmethod() | 把方法转换为类方法。 |
| compile() | 把指定的源作为对象返回，准备执行。 |
| complex() | 返回复数。 |
| delattr() | 从指定的对象中删除指定的属性（属性或方法）。 |
| dict() | 返回字典（数组）。 |
| dir() | 返回指定对象的属性和方法的列表。 |
| divmod() | 当参数1除以参数2时，返回商和余数。 |
| enumerate() | 获取集合（例如元组）并将其作为枚举对象返回。 |
| eval() | 评估并执行表达式。 |
| exec() | 执行指定的代码（或对象）。 |
| filter() | 使用过滤器函数排除可迭代对象中的项目。 |
| float() | 返回浮点数。 |
| format() | 格式化指定值。 |
| frozenset() | 返回 frozenset 对象。 |
| getattr() | 返回指定属性的值（属性或方法）。 |
| globals() | 以字典返回当前全局符号表。 |
| hasattr() | 如果指定的对象拥有指定的属性（属性/方法），则返回 True。 |
| hash() | 返回指定对象的哈希值。 |
| help() | 执行内建的帮助系统。 |
| hex() | 把数字转换为十六进制值。 |
| id() | 返回对象的 id。 |
| input() | 允许用户输入。 |
| int() | 返回整数。 |
| isinstance() | 如果指定的对象是指定对象的实例，则返回 True。 |
| issubclass() | 如果指定的类是指定对象的子类，则返回 True。 |
| iter() | 返回迭代器对象。 |
| len() | 返回对象的长度。 |
| list() | 返回列表。 |
| locals() | 返回当前本地符号表的更新字典。 |
| map() | 返回指定的迭代器，其中指定的函数应用于每个项目。 |
| max() | 返回可迭代对象中的最大项目。 |
| memoryview() | 返回内存视图（memory view）对象。 |
| min() | 返回可迭代对象中的最小项目。 |
| next() | 返回可迭代对象中的下一项。 |
| object() | 返回新对象。 |
| oct() | 把数转换为八进制。 |
| open() | 打开文件并返回文件对象。 |
| ord() | 转换表示指定字符的 Unicode 的整数。 |
| pow() | 返回 x 的 y 次幂的值。 |
| print() | 打印标准输出设备。 |
| property() | 获取、设置、删除属性。 |
| range() | 返回数字序列，从 0 开始且以 1 为增量（默认地）。 |
| repr() | 返回对象的可读版本。 |
| reversed() | 返回反转的迭代器。 |
| round() | 对数进行舍入。 |
| set() | 返回新的集合对象。 |
| setattr() | 设置对象的属性（属性/方法）。 |
| slice() | 返回 slice 对象。 |
| sorted() | 返回排序列表。 |
| @staticmethod() | 把方法转换为静态方法。 |
| str() | 返回字符串对象。 |
| sum() | 对迭代器的项目进行求和。 |
| super() | 返回表示父类的对象。 |
| tuple() | 返回元组。 |
| type() | 返回对象的类型。 |
| vars() | 返回对象的 dict 属性。 |
| zip() | 从两个或多个迭代器返回一个迭代器。 |
函数参数：
参数的传递过程，实际上是一个**赋值**的过程。在调用函数时，调用者的实际参数自动赋值给函数的形式参数变量。
def avg(m, n):
return (m + n) /2
print(avg(5, 2))
python实例
打印1-100
(python中包前不包后)
for a in range(1,101): #以“-”分隔开 print(a,end="-")
中文打印中文
打印 = print
打印("你好 世界")
输出结果：
你好 世界
向列表中 ‘增删改查’数据
-
向列表中追加元素10
s = ['1','2','3','4','5','6'] s.append(['10']) print(s)
结果：
['1', '2', '3', '4', '5', '6', ['10']]
-
向列表中追加10
s = ['1','2','3','4','5','6']
s.append('10')
print(s)
结果：
['1', '2', '3', '4', '5', '6', '10']
生成随机数random
#生成随机数 import random #生成任意随机数 a = random.random() print(a) # #如何生成0-9之间的随机数 # print(random.randint(0,9))
判断奇数偶数
a =int(input("输入一个数字： "))
if (a % 2 ==0):
print("这个数字是偶数")
else:
print("这个数字是奇数")
斐波那契数列（兔子数列）
0 1 1 2 3 5 8 13 21 34 55
#!/usr/bin/python3 import sys def fibonacci(n): # 生成器函数 - 斐波那契 a, b, counter = 0, 1, 0 while True: if (counter > n): return yield a a, b = b, a + b counter += 1 f = fibonacci(10) # f 是一个迭代器，由生成器返回生成 while True: try: print (next(f), end=" ") except StopIteration: sys.exit()
判断xxx是否在…内
列表中有1，2，3，4;判断数字2是否在列表中。
list=[1,2,3,4] print(2 in list)
True 进程已结束，退出代码为 0
将列表中元素 乘n倍
lis=['葫芦娃 '*10] print(lis)
['葫芦娃 葫芦娃 葫芦娃 葫芦娃 葫芦娃 葫芦娃 葫芦娃 葫芦娃 葫芦娃 葫芦娃 ']
对列表内容原地翻转
reverse( )
#lis.reverse() 对列表内容进行’原地倒转‘ lis=['张三','李四','王五','赵六','老七','小胡','小芳' *3] lis.reverse() print(lis)
print打印
1.直接打印：
print('hello','world','!')
结果：
hello world ! 进程已结束，退出代码为 0
2.分隔符的使用;print 打印默认换行，如何换行
print('hello','world','!',sep="-",end="****")
print('hello','world','!')
结果：
hello-world-!fanghello world ! 进程已结束，退出代码为 0
比较大小
例1：比较字符串大小**
根据首字母编码
print(max("a","b","c"))
结果：
c 进程已结束，退出代码为 0
例2：比较数字大小
print(max(1,6,8,-9,3,4,2))
结果：
8 进程已结束，退出代码为 0
比较绝对值大小
l = [3,2,-9,8,-6,4,88,56,-100] print(max(l,key=abs))
结果：
-100 进程已结束，退出代码为 0
例3：比较长度
A = ["aaa","bbbbb","c","dd"] print(max(A,key=len))
结果：
bbbbb 进程已结束，退出代码为 0
九九乘法表
for i in range(1,10):
for j in range(1,i+1):
print('{}x{}={}\t'.format(j,i,i*j),end=" ")
print()
1x1=1 1x2=2 2x2=4 1x3=3 2x3=6 3x3=9 1x4=4 2x4=8 3x4=12 4x4=16 1x5=5 2x5=10 3x5=15 4x5=20 5x5=25 1x6=6 2x6=12 3x6=18 4x6=24 5x6=30 6x6=36 1x7=7 2x7=14 3x7=21 4x7=28 5x7=35 6x7=42 7x7=49 1x8=8 2x8=16 3x8=24 4x8=32 5x8=40 6x8=48 7x8=56 8x8=64 1x9=9 2x9=18 3x9=27 4x9=36 5x9=45 6x9=54 7x9=63 8x9=72 9x9=81
三目运算
x=int(input("请输入x的值"))
y=int(input("请输入y的值"))
a=True if x>y else False
print(a)
结果：
请输入x的值4 请输入y的值5 False 进程已结束，退出代码为 0
![[Qt] Qt Creator 编译输出乱码，问题页中的报错、警告内容，编译输出乱码](https://img-blog.csdnimg.cn/direct/72889d169dc34b73ae1d9a1b84c9c1e1.png)
