python基本数据结构以及语法

基础语法知识

print不换行输出

print("hello world",end="")
print("goodbye world")

注释以及四则运算

"""
三个省略号之间可以写多行注释
"""
print(123+456)
print(123-596)
print(26*5)
print(23/4)
print(5%6)
# 两个/代表整除
print(23//6)
#两个*代表幂运算，2的6次方
print(2**6)

给变量取名

1. 字母（Unicode），数字，下划线，不能有特殊字符（！，+，-，…)，数字不能开头

2. 区分大小写，大小写敏感

3. 不能使用python中的关键字（python中有特殊含义的单词）和保留字（已经被python使用的名字）

4. 见明知意

5. 变量的名称全部小写，多个单词用下划线连接（Snake case)

整数输入

#强制类型转换，将字符型转换为整数类型
a=int(input("a1 = "))
b=int(input("a2 = "))

基础数据类型

a=123
b=1.23
c="hello"
d=True
#复数类型
e=3+5j
#输出a以及a的类型,print输出多个值的时候可以用逗号隔开
print(a,type(a))

不同进制的表示以及进制转换

#十进制
a=110
#八进制
b=0o110
#十六进制
c=0x110
#二进制
d=0b110
#bin --->binary 十进制转化为二进制
print(bin(47))
#oct ---> octal 十进制转化为八进制
print(oct(47))
#hex ---> hexadecimel 十进制转化为十六进制
print(hex(47))

浮点数的科学计数法

# 123 *10^-5,a仍然为浮点数
a=123e-5

print格式化输出

a1=float(input("a1="))
b2=float(input("a2="))

#与c语言类似
#保留一位小数进行输出
print('%.1f + %.1f = %.1f',%(a1,b2,a1+b2))
#求余的时候应该两个%，第一个表示占位符
print('%f %% %f = %f',%(a1,b2,a1%b2))

# f-format-格式化字符串
print(f'{a1}+{b2}={a1+a2}')
#运算结果保留一位进行输出
print(f'{a1}+{b2}={a1+a2:.1f}')

运算符

赋值运算符 =

算数运算符 + - * / // % **

复合的赋值运算符   +=   -=   *=   /=

关系运算符 （比较运算符）<   >   <=   >=  ==   !=

逻辑运算符 and  or  not(and 的优先级大于or)
print('-'*10)#将-输出十遍

运算符说明	Python运算符	优先级	结合性
小括号	( )	19	无
索引运算符	x[i] 或 x[i1: i2 [:i3]]	18	左
属性访问	x.attribute	17	左
乘方	**	16	右
按位取反	~	15	右
符号运算符	+（正号）、-（负号）	14	右
乘除	*、/、//、%	13	左
加减	+、-	12	左
位移	>>、<<	11	左
按位与	&	10	右
按位异或	^	9	左
按位或	|	8	左
比较运算符	==、!=、>、>=、<、<=	7	左
is 运算符	is、is not	6	左
in 运算符	in、not in	5	左
逻辑非	not	4	右
逻辑与	and	3	左
逻辑或	or	2	左
逗号运算符	exp1, exp2	1	左

终端掩码

#导入getpass模块，在输入密码时是掩码，但只有在终端才能体现
import getpass
password =getpass.getpass('密码:')

分支结构

#多分支结构
if :
   
elif:
    
else:
    pass  #空语句

循环结构

# for-in 循环

#循环一百次，从0，到99
for i in range(100):
    print('hello world')
    break #break依然存在
    
    
range()函数:range(100):从0到99,range(1,101,2),从1到100的奇数，2为步长，前闭后开空间;range(100,0,-2)从100到1的偶数，递减

#while 循环

while a==1:
    print('a==1')
    a++

sum函数

#从1到100累加求和
total=sum(range(1,101))

time函数（确定程序运行时间）

import time
start=time.time()


end=time.time()
print(f'程序执行时间：{end-start}')

产生随机数

import random

#产生从1到100的随机数
answer=random.randrange(1,101)

数据容器

列表（list)

列表的构造，增删和遍历以及基本函数

#创建列表字面量语法
nums=[10,11,12]#一个列表可以同时存放不同数据类型，
print(nums)

#列表的生成式语法
nums=[random.randrange(1,100) for _ in range(10)]#生成十个随机数列表

#构造器函数构造列表
nums=list(range(1,10))
nums=list(list1)

#追加元素
nums.append(15)

#插入
nums.insert(0,1)

#删除
nums.pop()#默认删除最后一个元素
nums.pop(0)#按照索引删除

nums.remove(5)#把第一个5删除

del nums[0]#将第一个元素删除

#列表元素个数
len(nums)

#遍历列表

nums[0]#按索引取值

nums.index(5,6)#从6位置开始找元素5的索引，index函数查找的元素必须存在于列表中

nums.count(5)#列表中5出现的次数
#循环遍历所有元素
for num in nums:#只读循环，不能对元素修改
    print(num)

for i in range(len(nums)):#读写循环，可进行修改
    print(nums[i])

for i,x in enumerate(nums):#可以同时获得索引和元素值
    print(i,x)

#对列表所有数据求和,最大值，最小值
sum(nums)
min(nums)
max(nums)

索引运算（下标运算）可以取正负值

和列表有关的运算

#重复运算
list1=[1,10]*3

#成员运算
print(100 in list1)#若100在list1则为真，反之为假
 
#索引和切片
正向索引 0~N-1,负向索引-N~-1

#合并运算
list5=[1,2,3]
list6=[4,5,6]
list5+=list6 or list5=list5+list6 [1,2,3,4,5,6]

#比较运算
list5==list6  若两个元组完全相同则返回True反之为False
list5>list6 从第一个元素逐个比较，若有一个不相等则进行判断

字符和编码的相互转换

ord('王')->将字符转化为编码

chr(0x12)->将编码转化为字符

列表的反转和排序

#反转，不再原来列表操作
items=[1,2,3]
items=item[::-1]

#反转，在原来列表操作
items.reverse()

#排序
items.sort()#升序
items.sort(reverse=True)#降序

元组（tuple)

不可变的容器，元素不能够改变，其他和列表一样

创建元组的时间空间开销小于列表

元组的定义

fruits=('apple','banana','grape')
#如果是一元组，则必须有逗号
fruits=('apple',)
元组没有生成式语法

元组的运算

fruits1=('apple','banana','grape')

#重复运算
fruits2=fruits1*3#得到一个新元组，fruits1没有变

#成员运算
'apple'in fruits1 #返回True

#合并运算
fruits3=('pitaya',)
fruits4=fruits1+fruits3 #得到一个新的元组，为两个元组累加

#索引和切片
print(fruits4[4],fruits4[-1])
print(fruits4[::-1])

fruits.index("apple")#索引
fruits.count('apple')#次数

#元组的解包打包
a,b,*c=1,2,3,4,5,6#6=1,b=2,c=[3,4,5,6]

集合(set)

无序性，互异性，确定性

集合低层运用的是哈希存储的存储方式

可变容器（列表、字典、集合）都无法计算哈希码，因此不能放到集合中作为集合的元素

集合的定义

#集合的字面量定义
set1={1,1,2,2,3,3,6}//实际中存放的是1,2,3,6,
set2=set()#空集的定义

#循环对集合元素的遍历
for elem in set1:
    print(elem)
 #定义不可变集合
set1=frozenset({1,1,1,222})

集合的运算

1. 成员运算 print(1 in set1) print(1 not in set1)
2. 交集 print(set1&set2) print(set1.intersection(set2))
3. 并集 print(set1|set2) print(set1.union(set2))
4. 差集 print(set1-set2) print(set1.difference(set2))
5. 对称差 print(set1^set2) print((set1|set2)-(set1&set2)) print(set1.symmetric_difference(set2))

集合的方法

set1={'apple','banana'}
#添加
set1.add("graple")

#删除
set1.pop()#随机删除一个元素并返回

set1.discard('apple')#指定一个元素删除，无返回值
#清空
set1.clear()

#判断是否为子集
print()

#列表和集合的相互转换
nums=[1,1,2,2,4,5,3,4]
set1=set(nums)#将列表转化为集合
print(set1)
list1=list(set1)#将集合转化为列表
print(list1)
上述操作不保证顺序的保持

字典（dictionary)

字典元素由键和值两部分构成，冒号前为键，冒号后为值
键也就是索引，为不可变数据类型

字典的定义

# 字面量语法
student={'id':1001,'name':'Jon','favourites':['写代码'，'学习']}
#构造器函数
student=dict(id=1001,name='Jon')
#生成式语法
items3 = {num: num ** 2 for num in range(1, 10)}

字典的遍历

for key in student:#先遍历所有的键
    print(key,student[key])

for key in student。keys():#先遍历所有的键
    print(key,student[key])

for value in student.values():#先取出所有的值
    print(value)
 
for key,value in student.items():#先取出所有键值对
    print(ley,value)

字典的运算

#成员运算
print('name'in student)

#索引运算放在赋值运算符的左边
#有则更新，无则添加
student['name']='KKK'
student['address']='山东聊城'

#使用get函数通过key获取value时，如果key不存在，不会报错，而是得到一个空值
print(student.get('age'))
#也可以设置一个默认值,没有则返回默认值
print(student.get('age',20))

字典的相关函数

dict1={'A':100,'B':200}
dict2={'C':200,'B':500}
#元素的合并(更新)
dict1.update(dict2)

#删除
del dicts1['B']
dic1.pop('B')
dic.popitem()#默认将最后一个删除
print(student.pop('name'))

#清空
dic1.clear()

#没有键值对则增添，并返回第二个参数，默认为None，如果已经有返回值，
print(dic1.setdefault('C',800))

#通过zip函数将两个序列压成字典
items2 = dict(zip(['a', 'b', 'c'], '123'))
#将键值地位互换
dic3=dict(zip(dic1.keys(),dict2.values))

#按照字典的值对键进行排序
print(sorted(stocks,key=stocks.get,reverse=True))

#获取按照值比较，最大、最小的键
print(max(stocks,key=stocks.get))
print(min(stocks,key=stocks.get))

字符串

字符串只读，不能够通过索引改写，除了使用相对应的函数

字符串的定义

a='hello'
b="hello"
c='''hello
world
'''

转译\
a='\'hello\''

#原始字符，每个字符串都是原始含义，没有原始含义
d=r'\hello'

#格式化字符串
e=f'文件路径{d}'

#Unicode统一编码
s='\u9a56'

字符串的运算

a='hello'
#重复运算
print(a*5)‘

#成员运算
print('he'in a)

#比较运算
b='hello'
print(a==b)#a,b内容完全相同时返回真
print(a!=b)
print(a>b)#大小比较也是按字母一个个比较编码
print(a<b)

#获取字符串长度
print(len(a))

#循环遍历字符串每个字符
for i in a:
    print(a)
for i in range(len(a)):
    print(a[i])
 

字符串相关的函数

a='i Love you'

print(a.lower())#输出字符串全部变成小写
print(a.upper())#输出全大写

print(a.capitalize())#首字母变大写
print(a.title())#每个单词首字母大写


print(a.isdigit())#判断是否是纯数字组成
print(a.isalpha())#判断是否是纯字母组成
print(a.isalnum())#判断是否以数字和字母组成
print(a.isascii())#判断是否由ASCII码组成
print(a.startswith('你'))#判断字符串是否以指定内容开头
print(a.endswith('我'))#判断字符串是否以指定内容结尾


查找子串是否存在
a='Oh,apple,i love apple.'
#从第十个字符之后（第十一个字符开始）找，可指定从哪开始找，默认为0，找到返回索引，反正程序崩溃
print(a.index('apple'，10))
print(a.rindex('apple'))#从右往左找

print(a.find('apple'))#找不到时返回-1
print(a.rfind('apple'))

格式化字符串

字符串对齐方式

#居中
print(a.center(80,'_'))
#右对齐
print(a.rjust(80,'_'))
#左对齐
print(a.ljust(80,'_')
#零填充
print(a.zfill(6))#在a的左边填充5个零
      
#字符串的格式化
c=123
d=156   
print(f'{c}+{d}={c+d}')
print('{}+{}={}'.format(c,d,c+d))
print('{2}+{1}={}'.format(c,d,c+d))

      

字符串的拆分合并，修剪，编码解码

email='  cuihongxi   '
print(email.strip())#修剪左右两端的空格
print(email.lstrip())#修建右两端的空格
print(email.rstrip())#修建左两端的空格

print(email.replace('cui','*').replace('hong'),'_')

#字符串的拆分
words=content2.solit(' ',maxsplit=3)#指定拆分依据，拆分最大次数，返回的结果为列表

#字符串的合并
contents=[ 'i','like','you']
print(''.join(content))#用指定字符合并列表元素为一个字符串


#编码
a='我爱你'
b=a.encode('gbk')
#解码
c=b.decode('gbk')
#编码解码方式不一样会产生异常或产生乱码现象

通过字符串的translate方法实现字符串的转译
message='attack at dawn.'
#生成字符串转换的对照表
table=str.maketrans('abcdefghijklmnopqrstuvwxyz','defghijklmnopqrstuvwxyzabc')
print(message.translate(table))

random

随机抽样

import random
#不放回随机抽样
random.sample(names,5)#从列表names里面随机抽取5个

#有放回抽样
random.choices(names,k=5) 

以上两个函数返回结果为列表

random.choice(names)#随机返回列表元素，返回值为列表元素

将列表打乱顺序

#将列表元素打乱
random.shuffle(names)

函数

代码有很多种坏味道，重复是最坏的一种

def f(x,y,z):
    return x;

局部变量和全局变量

local局部作用域

embeled嵌套作用域——>nonlocal使用嵌套作用域中的变量

global全局变量域

built-in内置作用域