初识Python
Python是一种解释型语言
Python使用缩进对齐组织代码执行，所以没有缩进的代码，都会在载入时自动执行
数据类型： 整形 int 无限大
浮点型 float 小数
复数 complex 由实数和虚数组成
Python中有6个标准的数据类型：
Number(数字)
String(字符串)
List(列表)
Tuple(元组)
Sets(集合)
Dictionart(字典)
其中不可变得数据：
Number(数字) String(字符串) Tuple(元组) Sets(集合)
可变得：
List(列表) Dictionart(字典)
print('hello world')终端运行代码
hello world标识符
用于给变量/常量/语句块等命名，用来标识某个实体的一个符号
标识符命名规则
由数字/字母/下划线组成，不能以数字开头，
以下划线开头的标识符有一定的特殊意义
ABC abc 标识符字母区分大小写
标识符不可以是python中的保留字
查看python中的保留字
import keyword
print(keyword.kwlist)
print(keyword.iskeyword('and'))终端运行代码
['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']
True
变量名
命名规则
（大驼峰MyName 小驼峰myName 下划线分隔my_Name)
数值型
整型、浮点型、布尔型、复数
#整形转浮点型时 在整数后面加 .0
print(float(2))终端运行代码
2.0
#浮点型、整形转布尔型时、 非0数值结果为Ture 其余为False
print(bool(1.0))终端运行代码
True
#浮点型转整型 将小数点剔除，保留整数位
print(int(5.3))
print(int(5.6))终端运行代码
5
5运算符
常见的操作运算符：算数、比较、赋值、按位、逻辑、成员、身份
+ - * / %(取模) //（取整） **（幂）
比较运算符
> < == >= <= !=
print(12>13)
print('a'>'b')终端运行代码
False
False
赋值运算符
= += -= *= /=
使用特殊的赋值运算时需要先定义变量 f+=4
按位运算符
&(与) |(或) ^（异或） ~（按位取反）
#ord函数将ASCII转化为十进制
print(ord('a'))
print(ord('b'))终端运行代码
97
98逻辑运算符
逻辑运算用于对布尔型变量进行运算，其结果也是布尔型
true 和 false 就是 布尔值。
运算顺序
先运算左右两边的表达式得出布尔值，再进行逻辑运算。
and（与）
and 布尔与 and 前面值为false，则输出and前面的值，反之亦然
print(12 and 13)终端运行代码
13or（或）
#or 或 or前面的值为true，则输出or前面的数，反之亦然
m=12;n=13
print(12 or 13)终端运行代码
12
not（非）
#not 布尔非
print(not(12))终端运行代码
False
成员运算符
in not in
print('m' in ['m',12,34])
print('l' in ['m',12,34])
print('l' not in ['m',12,34])终端运行代码
False
True
False
True身份运算符
is is not
x=90;y=12
print(id(x))
print(id(y))
print(x is y)
print(3.14*5.0*2.0)终端运行代码
140722735803976
140722735801480
False
31.400000000000002字典
字典属于映射类型的数据结构，可以包含任意数据类型的元素
创建字典 {} dict函数
mydict={'name':'tom','age':19,'国籍':'china'}
print(mydict)
终端输出
{'name': 'tom', 'age': 19, '国籍': 'china'}字典中的元素、键和值
字典中的元素以键值对的形式存在，字典中个元素都有与之对应的值
字典中键是唯一的，且是不可变的（字符串、数字、元组）
值不是唯一的，且可以是可变的数据类型，也可以是不可变的
字典中个元素都有与之对应的且唯一的键
双指子序列
dict函数：实际上将包含双值子序列的序列对象转换成字典 dict[]
包含两个元素的序列(‘专业’，‘大数据’)['sex','man']'ab'
1.将双值子序列组成员数组[]/列表()
dict1=dict([('专业','大数据'),['sex','man'],'ab'])
print(dict1)
终端输出
{'专业': '大数据', 'sex': 'man', 'a': 'b'}2、通过等于=将键隔开,键不允许重复的
dict2=dict(name='zhangsan',age=22)
print(dict2)
mydict1={'name':'tom','age':19,'国籍':'china','age':22,'age':10000}
print(mydict1)
终端输出
{'name': 'zhangsan', 'age': 22}
{'name': 'tom', 'age': 10000, '国籍': 'china'}提取元素
无索引 无切片 通过键值对的方式提取
mydict2={'name':'tom','age':19,'国籍':'china'}
已知键为name求其对应的值,注意：键要存在于字典中
print(mydict2['name'])
print('判断键是否存在于字典中')
print('name'in mydict2)
print(mydict2.get('name'))
终端输出
tom
判断键是否存在于字典中
True
tom弱碱不存在字典中输出none
print(mydict2.get('summer')
终端输出
None弱碱不存在于字典中输出“改内容不存在”
print(mydict2.get('summer','改内容不存在'))
终端输出
该内容不存在已知值为china求对应的键
jian=mydict2.keys()
zhi=mydict2.values()
print(jian)
print(zhi)
终端输出
dict_keys(['name', 'age', '国籍'])
dict_values(['tom', 19, 'china'])
j=list(jian)
z=list(zhi)
print(j)
print(z)
终端输出
['name', 'age', '国籍']
['tom', 19, 'china']
z1=z.index('china')
print(z1)
print(j[2])
终端输出
2
国籍
增添元素
mydict3={'name':'tom','age':19,'国籍':'china'}
mydict3['sex']='man'
print(mydict3)
终端输出
{'name': 'tom', 'age': 19, '国籍': 'china', 'sex': 'man'}
update
other={'专业':'大数据','身高':'180'}
mydict3.update(other)
print(mydict3)
终端输出
{'name': 'tom', 'age': 19, '国籍': 'china', 'sex': 'man', '专业': '大数据', '身高': '180'}
删除元素 pop del
del mydict3['sex']
print(mydict3)
mydict3.pop('age')
print(mydict3)
终端输出
{'name': 'tom', 'age': 19, '国籍': 'china', '专业': '大数据', '身高': '180'}
{'name': 'tom', '国籍': 'china', '专业': '大数据', '身高': '180'}修改元素
mydict3['身高']=185
print(mydict3)
终端输出
{'name': 'tom', '国籍': 'china', '专业': '大数据', '身高': 185}集合
集合就是将值抽离，只存在键的字典
zidian={'name':'tom'}
jihe={'name'}
集合是不可变的数据类型
根据数据结构对象划分，分为可变集合和不可变集合
可变集合
#创建可变集合 {} set函数
set1={'name',2,(23)}
myset=set(('name',2,5))
print(myset)
终端输出
{'name', 2, 5}
不可变集合
#创建不可变集合 frozenset
myset1=frozenset(('name',2,5))
print(myset1)
终端输出
frozenset({'name', 2, 5})运算方法（交集 并集 差集 异或集）
set1={'java','c','c++','python','c#'}
set2={'web','html','css','js','python'}
交集 & intersection
print(set1&set2) set1.intersection(set2) s=set1.intersection(set2) print(s)
终端输出
{'python'}
{'python'}并集 | union
print(set1|set2) print(set1.union(set2))
终端输出
{'c', 'java', 'js', 'c#', 'css', 'web', 'c++', 'html', 'python'}
{'c', 'java', 'js', 'c#', 'css', 'web', 'c++', 'html', 'python'}差集 - difference
print(set1-set2) print(set2-set1) s1=set1.difference(set2) print(s1) s2=set2.difference(set1) print(s2)
终端输出
{'c++', 'c', 'c#', 'java'}
{'html', 'js', 'css', 'web'}
{'c++', 'c', 'c#', 'java'}
{'html', 'js', 'css', 'web'}异或集 ^ symmetric_difference 求两集合的不同部分
print(set1^set2) s3=set2.symmetric_difference(set1) print(s3)
终端输出
{'c', 'html', 'web', 'java', 'c++', 'js', 'c#', 'css'}
{'java', 'c#', 'c', 'js', 'css', 'web', 'c++', 'html'}运算符 > <= > >=
子集{1,2}{1,3}{2,3}{1}{2}{3}{1,2,3}空集 真子集{1}{2}{3}{1,2}{1,3}{2,3}空集
set5={1,2,3,}
set4={1,3}< 用来判断某集合是否为另一集合的真子集
print(set5<set4) #set5是否为set4的真子集 print(set4<set5)
终端输出
False
True<=或 issubset 用来判断某集合是否为另一集合的子集
print(set4<=set5) s4=set5.issubset(set4) print(s4)
终端输出
True
False# > 用来判断某集合是否为另一集合的真超集 集合A中包含了集合B中的所有元素，也包含了集合B中没有的元素
print(set5>set4)
终端输出
True
>= 或 issuperset 用来判断某集合是否为另一集合的超集 集合A中包含集合B中所有元素
print(set5>=set4)
s5=set4.issuperset(set5)
print(s5)
终端输出
True
False可变集合常用的函数和方法
增添 add（添加单个元素） update（增添多个元素）
set3={'web','html','css','js','python'}
set3.add('jquery')
print(set3)
other={'mysql','linux'}
set3.update(other)
print(set3)
终端输出
{'css', 'html', 'web', 'python', 'jquery', 'js'}
{'css', 'html', 'web', 'python', 'jquery', 'linux', 'mysql', 'js'}删除 pop
随机进行删除
set3.pop()
print(set3)
固定删除
set3.remove('css')
print(set3)
{'html', 'web', 'python', 'jquery', 'linux', 'mysql', 'js'}clear 清除内容
set3.clear()
print(set3)
set()
len 查看长度
print(len(set3))
0列表
总结
1.数据结构类型:数字、字符串、列表、元组、字典
2.序列（列表、元组）：数据结构元素的有序排列
3.列表：可变数据类型 元组：不可变数据类型
创建列表 [] list函数
mylist1=[1,2,3,4,5] print(mylist1) mylist2=list((1,2,3,4)) print(mylist2)
[1, 2, 3, 4, 5]
[1, 2, 3, 4]列表索引提取 1.索引提取 2.切片提取
mylist3=[1,2,[3,4],4,5,'one'] print(mylist3[5]) print(mylist3[5:6]) print(mylist3[1:5:2]) #步长为2,步长不能为0，步长为一的时候可以省略 print(mylist3[-1:-5:-2])
one
['one']
[2, 4]
['one', 4]
列表元素的增加
1.append 2.extend 3.insert
append 只能添加一个元素
list1=['one','two','three']
list1.append('six')
print(list1)
['one', 'two', 'three', 'six']extend添加多个元素
other=['three','five']
['one', 'two', 'three', 'six', 'three', 'five']insert指定位置添加元素
list6=['12','2','3']
list6.insert(1,'five')
print(list6)
['12', 'five', '2', '3']列表元素的删除
del pop remove
list2=['one','two','three','four']
del删除是要先写del 然后写列表名称 中括号里面
del list2[2]
print(list2)
['one', 'two', 'four']
pop语句中无任何参数时，默认删除的是索引为-1的参数
list2.pop(2)
print(list2)
list2.pop()
print(list2)
['one', 'two']
['one']
remove删除指定元素
list3=['one','two','three','four']
list3.remove ('three')
print(list3)
['one', 'two', 'four']列表元素的修改
list4=['one','two','three','four'] list4[2]='six' print(list4)
['one', 'two', 'six', 'four']列表元素的查询
in 判断某元素是否存在于列表中 index查询该元素在列表中
list5=['one','two','three','four']
print('one' in list5)
print(list5.index('one'))
True
0列表中常见函数
num=[2,4,6,3,7,10,6]
count 用来查看列表中某元素出现的次数
print(num.count(6))
2
sort对列表中的元素进行排序，默认为升序
num.sort()
print(num)
num.sort(reverse=True)
print(num)
[2, 3, 4, 6, 6, 7, 10]
[10, 7, 6, 6, 4, 3, 2]元组
元组和列表的异同
相同：有序元素的集合，并且都可以包含任意类型元素
不同：列表是可变数据类型 元组是不可变数据类型
创建元组 （）tulpe函数
t1=(1,5,0)
print(t1)
t2=tuple((1,5,0))
print(t2)
(1, 5, 0)
(1, 5, 0)list1=[4,6,8]
tl=tuple(list1)
print(tl)
print(type(tl))
(4, 6, 8)
<class 'tuple'>元组中元素的提取
1、索引提取 2、切片提取
mytuple=('计算机','大数据','人工智能','电子商务')
print(mytuple[1])
print(mytuple[1:3])
大数据
('大数据', '人工智能')#元组解包；将元素各个元素分别赋值给多个不同的变量
mytuple=('计算机','大数据','人工智能','电子商务')
a,b,c,d=mytuple
print(a)
计算机常见的函数
count
查看元组中某元素出现的次数
t3=(3,4,5,6,4,3)
print(t3.count(4))
2
sorted
对元素进行排序
print(sorted(t3))
[3, 3, 4, 4, 5, 6]index
查看元素第一次出现的位置对应的索引
print(t3.index(5))
2
len
查看元组中元素的长度
print(len(t3))
6
8250
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
