这些都是比较简单的
python语言简介
1、python编程语言
编程语言，可以理解为人类通过计算机指令与计算机沟通交流的语言，python是众多计算机编程语言中的一种。
2、Python的特点
Python支持面向对象的编程思想，有着极其简单的语法，可以移植到Linux、Windows等众多系统平台， 具有可扩展性(部分程序可以使用其他语言编写，如c/c++。)、可嵌入型(可以把Python嵌入到c/c++程序中)以及非常丰富的专业库，是免费、开源的解释性的高层计算机语言。
编程入门
1、代码注释
可以起到一个备注的作用，团队合作的时候，个人编写的代码经常会被多人调用，为了让别人能更容易理解代码的通途，使用注释是非常有效的。
①：单行注释以 # 开头
# 这是一个注释
print('Hello, World!')
②：多行注释用三个单引号 ''' 或者三个双引号 """ 将注释括起来
'''
这是多行注释，用三个单引号
这是多行注释，用三个单引号
这是多行注释，用三个单引号
'''
print('Hello, World!')
"""
这是多行注释，用三个双引号
这是多行注释，用三个双引号
这是多行注释，用三个双引号
"""
print('Hello, World!')
打印输出
print('hello')
print('python')
运行结果：
hello python
注意：print()在输出完，内容后会自动换行，如果我们不需要输出后换行，可以通过end参数，指定输出后内容的结束形式
print('hello',end='')
print('python',end='')
运行结果：
hellopython
连续输出多个内容，将要输出的内容之间用,分开
print("5","中国",True)
运行结果：
中国 True
转义字符的使用
①、输出语句含有('、""、\等)特殊字符时需要使用 \ 转义
print('\\') # print('\') 程序会报错误
运行结果：
\
\n 代表换行
print('我爱你\n中国')
运行结果：
我爱你 中国
\t 代表八个空格
print('我爱你\t中国')
运行结果：
我爱你 中国
变量
是计算机语言中能储存计算结果或能表示值抽象概念（会在计算机内存中开辟一块空间）。
定义格式：变量名 = 初始化值
1、变量：可以被改变的量(存储数据的空间,类似于容器)
name = '小红' print(name) name = '小李' #小李 会覆盖掉 小红 print(name)
运行结果：
小红 小李
多目标赋值(不建议使用)
num1,num2 = 3,4 #第一种方式 print(num1) print(num2) num3 = num4 =5 #第二种方式 print(num3) print(num4)
运行结果
3 4 5 5
命名规则：
①、只能是字母、数字、下划线组成，不能以数字开头
②、字母大小写敏感代表不同含义，不能使用python保留的关键字
命名规范：
①、见名知义，尽量不要用小写字母i和大写字母的O(避免与数字1、0混淆)
注意： 变量，必须设置初始化值，以达到节省内存空间的原则(从计算机内存条开辟出来的)
标准数据类型
对所有数据分类的划分，解决数据更方便的管理、表述及使用。
Python3 中有六个标准的数据类型
1、Number(数字)
2、String(字符串)
3、List(列表)
4、Tuple(元组)
5、Set(集合)
6、Dictionary(字典)
注意：
可以使用 type(对象) 函数来查看数据类型
不可变的对象：数字 、元组 、字符串
Number(数字) 类型
Python3的数字类型支持 int、float、bool、complex（复数）
1、int -> 整数
表示为长整型，包含正整数和负整数,在这里整数被允许具有无穷的精度 （只要内存空间允许，它可以增长成任意位数的数字）
age = 18 #年龄
score = 90 #成绩
print('年龄是：',age)
print('成绩是',score)
print(type(score))
运行结果：
年龄是：18 成绩是 90 <class 'int'>
float -> 小数
表示为小数，带一个小数点，也可以加上一个科学计数标志e或者E
avg_score = 90.5 #平均成绩
price = 99.8 #单价
num_value = 3.14e-10 #科学计数
print('平均成绩为：',avg_score)
print('单价为：',price)
print('科学计数的值：',num_value)
print(type(price))
运行结果：
平均成绩为：90.5 单价为：99.8 科学计数的值：3.14e-10 <class 'float'>
bool -> 布尔(判断)
表示为布尔类型，值为True 和False，也可以用数字表示：0 表示 False，1 表示 True ，同时也可以进行运算
isTrue = True
isHeight = False
isTrue2 = 1
isHeight2 = 0
isValue = isTrue+isTrue2
print('isTrue的值是：',isTrue)
print('isHeight的值是：',isHeight)
print('isTrue2的值是：',isTrue2)
print('isHeight2的值是：',isHeight2)
print('isValue的值是：',isValue)
print(type(isTrue))
运行结果：
isTrue的值是：True isHeight的值是：False isTrue2的值是：1 isHeight2的值是：0 isValue的值是：2 <class 'bool'>
complex -> 复数
复数常量写成实部+虚部的写法，虚部是以j或J结尾的
compileValue = 3+4j
print('compileValue的值为：',compileValue)
print(type(compileValue))
运行结果：
compileValue的值为：(3+4j) <class 'complex'>
python序列
就是有序存放的一组数据，这组数据由一个个独立的元素组成
1、python中六种序列：
列表、元组、字符串、Unicode字符串、buffer对象、xrange对象
2、python序列特征：
①、元素有序存放，并每个元素都有一个索引，从0开始......
②、序列都能够进行索引操作、切片操作、加法运算、乘法运算和检查元素
根据索引修改或查找元素的值，根据元素的值查找元素的索引
切片操作能够获取序列中任意一段的数据
③、能够自动计算出序列类型的长度len()，最大值max()、最小值min()
String(字符串) 类型
1、简单使用
字符：所有的单个数字、文字、字母以及特殊的符号都叫字符
字符串：多个字符连接的串
①、单行字符串用‘...’ ， “...”来定义
name = '小红'
name2 = "小花"
print("name的值为：",name)
print("name2的值为：",name2)
运行结果：
name的值为：小红 name2的值为： 小花
多行字符串用'''...''' ， """..."""来定义
info = '''我是一个帅哥
！'''
info2 = """我是一个帅哥
很帅！"""
print("info的值为：",info)
print("info2的值为：",info2)
运行结果：
info的值为：
我是一个帅哥
info2的值为：
我是一个帅哥 很帅！
字符串格式化
问题：求100+300的和，在屏幕上输出：100+300=400
①、format实现
num01 = 100
num02 = 300
print(num01+num02)
print('100+300={}'.format(num01+num02)) #不写，默认从0开始
print('{}+{}={}'.format(num01,num02,(num01+num02))) #不写占位符的下标，默认从0开始
# 后面值的顺序要与前面占位符下标的顺序保持一致
print('{0}+{1}={2}'.format(num02,num01,(num01+num02)))
运行结果:
400 100+300=400 100+300=400 100+300=400
%实现
num01 = 100
num02 = 300
print(num01+num02)
print('100+300=%i'%(num01+num02))
# 后面值的顺序要与前面占位符的顺序保持一致
print('%i+%i=%i'%(num01,num02,(num01+num02)))
运行结果：
400 100+300=400 100+300=400
注意：推荐使用format，可以复用："5+3={0},5-3={1}{0}".format(5+3,5-3)
3、字符串操作
字符串中的字符都是有索引的，从0开始。
字符串是序列，是用索引来表示元素的位置的，因此凡是对元素的操作，都离不开索引。
①、len(字符串名)：计算字符串的长度
s = 'divpspan'
print('字符串的长度为：{}'.format(len(s)))
运行结果：
字符串的长度为：8
根据序列索引找字符
注意：正向索引从左边开始计算，从0开始，反向索引从右边开始计算，从最后一个(-1)开始
str = 'divpspan'
print('索引为4的字符时：{}'.format(str[4])) #正向索引（左[0开始] -> 右）
print('索引为-1的字符时：{}'.format(str[-1])) #反向索引（右[-1开始] -> 左）
运行结果：
索引为4的字符时：s 索引为-1的字符时：n
合并
字符串作为一个序列，字符串支持用+,+=进行拼接，或者用*进行重复
+,+=操作时，只要两边都是字符串叫做字符串连接符；反之为操作运算符；数值与字符串不能互相运算和连接
#只要两边都是字符串叫做字符串连接符；反之为操作运算符
#print("6"+9) #报错：数值与字符串不能互相运算
print(6+9) #运算符
print('6'+'9') #字符串连接符
print('8'*3) #将前面字符串复制3倍
运行结果：
15 69 888
④、title() 将每个单词的首字母都改为大写
info_val = 'i love you' print(info_val.title())
运行结果：
I Love You
⑤、upper()将字符串改为全部大写或lower()改为全部小写
info_val = 'i lOvE yOU' print(info_val.upper()) #改为全部大写 print(info_val.lower()) #改为全部小写
运行结果：
I LOVE YOU i love you
⑥、删除空格
剔除字符串末尾的空白：rstrip()
剔除字符串开头的空白：lstrip()
剔除字符串两端的空白：strip()
strValue = ' i love you ' print(strValue.rstrip()) #删除字符串末尾空格 print(strValue.lstrip()) #删除字符串开头空格 print(strValue.strip()) #删除字符串两端的空格
运行结果：
i love you i love you i love you
⑦、raw字符串
raw字符串表示原始字符串：你看到这个字符串是什么就显示什么，所有字符都不进行转义
写法：在字符串前面加r
作用：如果一个字符串包含很多需要转义的字符，对每一个字符都进行转义会很麻烦，可以通过在字符串前面加r，抑制转义，里面的字符就不会转义了
abc = '\\' #只打印一个\(一个\作为转义) defg = r'\\' #通过使用r 字符串中的字符将都不做转义 print(abc) print(defg) url = 'd:\tbc\def\gfh\t' #\t 转义操作 url2 = r'd:\tbc\def\gfh\t' #通过使用r 字符串中的字符将都不做转义 print(url) print(url2)
运行结果：
\ \\ d: bc\def\gfh d:\tbc\def\gfh\t
⑧、字符串分片
分片：从一个字符串中取出一部分的方法。
格式：X[I:J] 含义：取出在X中从偏移量为I，直到但不包含偏移量为J的内容。
注意：分片的左边界默认为0，右边界默认为分片序列的长度
s1 = 'adfj,k=国l78wm' print(s1[1:6]) #得到切片：dfj,k print(s1[2:-3]) #得到切片：fj,k=国l7 print(s1[:-3]) #得到切片：adfj,k=国l7 #左边不写，默认值为从0开始 右边不写，默认值是序列的长度len(s1) print(s1[:]) #得到切片：全部内容 print(s1[:len(s1)]) #得到切片：全部内容 #序列从左往右...(从最后一个切，是没有值的) print(s1[-1:1])#没有输出 #结果为去除掉最后一个字符 print(s1[:-1])#得到切片：adfj,k=国l78w
运行结果：
dfj,k fj,k=国l7 adfj,k=国l7 adfj,k=国l78wm adfj,k=国l78wm adfj,k=国l78w
⑨、类型转换 隐式转换(自动类型转换)：小范围类型数据向大范围类型数据转换，自动完成。
num1 = 8.2+5 #3自动转为浮点型，输出：13.2
运行结果：
13.2
显示转换(强制类型转换)：手动指定数据的类型
# num = '8'+3 #报错 需要转换
num2 = int('2')+3 #将str类型的数据”2”转为int类型数据2，输出：5
num3 = '2'+str(3) #将int类型的数据3转为str类型数据”3”，输出：23
num4 = int(3.2) #将float类型的数据转为int类型数据，输出：3
print(num1)
print(num2)
print(num3)
print(num4)
运行结果：
5 23 3
⑩、字符串的特点
特点：不可变性——在创建后不能就地改变。
注意：不能通过任何操作对原始的字符串进行改变，每个字符串都被定义为生成新的字符串作为其结果。在核心类型中，数字，字符串和元组是不可变的；列表和字典是可变的。
List(列表) 类型
列表是序列，能存放多个元素的容器
是一个任意类型的对象(元素)的位置相关的有序集合，它没有固定大小(长度可变)。
1、列表常用操作
student = ['张三','李四','王五'] print(student[1]) #根据索引找元素 print(len(student)) #列表的长度 print(student[1:3]) #分片的应用 num_list2 = [] #定义空列表
运行结果：
李四 3 ['李四', '王五']
2、追加列表元素
student = ['张三','李四','王五']
#末尾追加一个元素
student.append('赵六')
print(student)
#末尾追加一个列表
s2=['小明','小红']
student.extend(s2)
print(student)
#追加任意位置，原位置占用，后面元素后移
student.insert(1,'小丽')
print(student)
运行结果：
['张三', '李四', '王五', '赵六'] ['张三', '李四', '王五', '赵六', '小明', '小红'] ['张三', '小丽', '李四', '王五', '赵六', '小明', '小红']
3、修改列表元素
要修改列表元素，可指定列表名和要修改的元素的索引，再指定该元素的新值
student = ['张三','李四','王五'] student[1]='小王'; print(student)
运行结果：
['张三', '小王', '王五']
4、删除列表元素
student = ['张三', '小丽', '李四', '王五', '赵六', '小明', '小红']
#根据索引删除元素
del student[1]
print(student)
#pop返回被删除的元素
#默认删除最后一个元素
student.pop()
print(student)
student.pop(1) #删除索引为 1的元素
print(student)
#删除（根据元素的值），返回值为被删除的元素
#删除一个不存在的元素，会报错
student.remove('小明')
print(student)
运行结果：
['张三', '李四', '王五', '赵六', '小明', '小红'] ['张三', '李四', '王五', '赵六', '小明'] ['张三', '王五', '赵六', '小明'] ['张三', '王五', '赵六']
5、对列表元素排序
#sort() 对列表进行永久性排序，将原列表改变，升序 num_list = [1,5,7,4,9,33,2] num_list.sort() print(num_list) #[1, 2, 4, 5, 7, 9, 33] #降序 num_list.sort(reverse = True) print(num_list) #[33, 9, 7, 5, 4, 2, 1] #对原列表，做临时排序不会更改原列表 num_list2 = sorted(num_list) print(num_list2) #[1, 2, 4, 5, 7, 9, 33] 数据临时改变 print(num_list) #[33, 9, 7, 5, 4, 2, 1] 原来列表数据没有改变 #反转列表元素：按照中心轴转一圈 num_list.reverse() print(num_list) #[1, 2, 4, 5, 7, 9, 33]
运行结果：
[1, 2, 4, 5, 7, 9, 33] [33, 9, 7, 5, 4, 2, 1] [1, 2, 4, 5, 7, 9, 33] [33, 9, 7, 5, 4, 2, 1] [1, 2, 4, 5, 7, 9, 33]
6、列表的特殊操作
num_list2 = [] #定义空列表 num_list3 = [6,0,5] num_list2.append(num_list3) print(num_list2) # [[6, 0, 5]] num_list2.append(num_list3) print(num_list2) #[[6, 0, 5], [6, 0, 5]] print(num_list2[0][1]) # 0 #列表不能自己加自己（会循环加下去...） num_list3.append(num_list3) print(num_list3) #[6, 0, 5, [...]]
运行结果：
[[6, 0, 5]] [[6, 0, 5], [6, 0, 5]] 0 [6, 0, 5, [...]]
Tuple(元组) 类型
元组与列表类似，不同之处在于元组的元素不能修改(元素不能改变顺序、不能增伤改元素、不能给元组的元素赋值)
相比于列表，元组是更简单的数据结构，如果需要存储的一组值在程序的整个生命周期内都不变，可使用元组。
元组可以存放任意类型
可以定义一个空的元组，但意义不大（因为它不能增删改）
number = (1,5,8,2,10) print(number[1]) #使用索引 print(number[:3]) #使用切片
运行结果：
5 (1, 5, 8)
虽然不能修改元组的元素，但可以给存储元组的变量赋值。因此，如果要修改数据，可重新定义整个元组：
numbers = (200, 50) print(numbers) numbers = (1,2,3,4) print(numbers)
运行结果：
(200, 50) (1, 2, 3, 4)
Dictionary (字典)
是一系列键值对，每个键都与一个值相关联，你可以使用键来访问与之相关联的值
与键相关联的值，可以是数字、字符串、列表、字典（事实上，可将任何python对象用作字典中的值）
字典的键是无序，键不能重复，重复后，后面的值会覆盖前面的值
zidian = {'身高':175,'体重':130,'肤色':'黄色'}
print(zidian) #查看字典结构
print(type(zidian)) #查看类型
print(zidian['体重']) #查看字典键'体重'的值
zidian['性别'] = '男' #增加一个键值对元素
print(zidian)
zidian['身高'] = 180; #增加一个存在的键，等同于修改
print(zidian)
#根据键删除字典元素
del zidian['肤色']
print(zidian)
zidian.pop('身高')
print(zidian)
#创建一个空的字典
zidian2 = {}
print(zidian2)
运行结果：
{'身高': 175, '体重': 130, '肤色': '黄色'}
<class 'dict'>
130
{'身高': 175, '体重': 130, '肤色': '黄色', '性别': '男'}
{'身高': 180, '体重': 130, '肤色': '黄色', '性别': '男'}
{'身高': 180, '体重': 130, '性别': '男'}
{'体重': 130, '性别': '男'}
{}
Set(集合) 类型
是一个无序(没有索引，没有顺序)不重复元素的序列,类似于字典，是一组不存储value的key的集合
set集合不支持索引
作用如下：
①、去重：把一个列表变成集合，就自动去重啦
②、测试两组数据之前的交集、差集、并集等关系
1、简单操作
ss1 = {1,5,3,4,2,1,'c','b','a','d'}
#查看类型
print(type(ss1))
#查看集合结构 -> 元素自动去重
#打印结果无序，结果根据计算机底层编码有关
print(ss1)
#成员运算符: in ，如果在指定的序列中找到值，返回True,否则返回False
print(5 in ss1) #判断集合中是否存在 5
运行结果：
<class 'set'>
{1, 2, 3, 4, 5, 'c', 'b', 'd', 'a'}
True
2、列表List与集合转换Set
#将列表list转换成集合set -> 元素自动去重 list_num = [1,2,3,4,5,1,6] ss2 = set(list_num) #查看对象类型 print(type(list_num)) print(type(ss2)) print(ss2) #将set转换成list list2 = list(ss1); print(type(list2))
运行结果：
<class 'list'>
<class 'set'>
{1, 2, 3, 4, 5, 6}
<class 'list'>
3、集合运算
set01 = set('abcda')
set02 = set('afg')
print(set01) #{'a', 'b', 'd', 'c'}
print(set02) #{'g', 'a', 'f'}
#差集 a中不包含b的东西
print(set01-set02) #{'c', 'b', 'd'}
#并集 a与 b中所有不重复的元素
print(set01|set02) #{'g', 'c', 'f', 'a', 'b', 'd'}
#交集 a与 b中共同有的元素
print(set01&set02) #{'a'}
#a 和 b中不同时存在的元素
print(set01^set02) #{'g', 'c', 'b', 'f', 'd'}
运行结果：
{'a', 'b', 'd', 'c'}
{'g', 'a', 'f'}
{'c', 'b', 'd'}
{'g', 'c', 'f', 'a', 'b', 'd'}
{'a'}
{'g', 'c', 'b', 'f', 'd'}
常用集合操作
ss10 = set([1,2,3]) print(ss10) ss10.add(5) #填加一个元素 print(ss10) ss10.update([8,9,0]) #填加多个元素 print(ss10) ss10.remove(5) #删除一个元素 print(ss10)
运行结果：
{1, 2, 3}
{1, 2, 3, 5}
{0, 1, 2, 3, 5, 8, 9}
{0, 1, 2, 3, 8, 9}
个人推荐入门学习较好的网站 https://www.liaoxuefeng.com/wiki/1016959663602400/1016959735620448
我的入门就是看廖大师的杰作学习的 希望小伙伴们努力加油!!!
QQ1696630419