python学习--基础语法及函数

Python发展历史: https://baike.baidu.com/item/Python/407313?fr=aladdin

 

 

变量

程序中，数据都是临时存储在内存中，为了更快速的查找或使用这个数据，通常我们把这个数据在内存中存储之后定义一个名称，这个名称就是变量。

二、定义变量

2.1标识符

2.2命名习惯

见名知义。
大驼峰:即每个单词首字母都大写，例如︰MyName 。
小驼峰:第二个(含）以后的单词首字母大写，例如:myName 。

下划线︰例如:my_name

Python 标识符

在 Python 里，标识符由字母、数字、下划线组成。

在 Python 中，所有标识符可以包括英文、数字以及下划线(_)，但不能以数字开头。

Python 中的标识符是区分大小写的。

以下划线开头的标识符是有特殊意义的。以单下划线开头 _foo 的代表不能直接访问的类属性，需通过类提供的接口进行访问，不能用 from xxx import * 而导入。

以双下划线开头的 __foo 代表类的私有成员，以双下划线开头和结尾的 __foo__ 代表 Python 里特殊方法专用的标识，如 __init__() 代表类的构造函数。

---

Python 保留字符

下面的列表显示了在Python中的保留字。这些保留字不能用作常数或变数，或任何其他标识符名称。

所有 Python 的关键字只包含小写字母。

and	exec	not
assert	finally	or
break	for	pass
class	from	print
continue	global	raise
def	if	return
del	import	try
elif	in	while
else	is	with
except	lambda	yield

行和缩进

学习 Python 与其他语言最大的区别就是，Python 的代码块不使用大括号 {} 来控制类，函数以及其他逻辑判断。python 最具特色的就是用缩进来写模块。

if True:
    print ("True")
else:
    print ("False")

缩进的空白数量是可变的，但是所有代码块语句必须包含相同的缩进空白数量，这个必须严格执行。（建议你在每个缩进层次使用 单个制表符 或 两个空格 或 四个空格 , 切记不能混用）

Python注释

python中单行注释采用 # 开头。

python 中多行注释使用三个单引号(''')或三个双引号(""")。

eval是Python的一个内置函数，这个函数的作用是，返回传入字符串的表达式的结果。

。

三、数据类型

格式化输出

f-格式化字符串是Python3.6中新增的格式化方法，该方法更简单易读。

 

#将输入的转化为整数
n=int(input('请输入一个整数\n'))
print(type(n))

#连续输入两个整数
m,n=map(int,input('请输入两个整数\n').split())
print(f'm:{m}\n,n:{n}')

#连续输入5个整数
nums=list(map(int,input('连续输入5个整数').split()))
for i in range(5):
    print(nums[i])

eval转换成原本的类型

运算符的分类

算数运算符

赋值运算符

 

复合赋值运算符 

 

比较运算符

逻辑运算符

字符串常用操作方法

字符串的常用操作方法有查找、修改和判断三大类。

查找

Python index() 方法检测字符串中是否包含子字符串 str ，如果指定 beg（开始） 和 end（结束） 范围，则检查是否包含在指定范围内，该方法与 python find()方法一样，只不过如果str不在 string中会报一个异常。

语法

index()方法语法：

str.index(str, beg=0, end=len(string))

修改

split分割字符串

合并字符串join

删除空白字符

列表可以一次性存储多个数据，且可以为不同数据类型。

 列表由一系列按特定顺序排列的元素组成。可以是不同的数据类型，元素之间可以没有关系。用[]方括号来表示，并用逗号分隔其中的元素。

用[]索引，索引从0开始，python提供了-1索引，返回最后一个列表元素，-2倒数第二个。负数索引返回离列表末尾相应距离的元素。【仅当列表为空时，这种访问最后一个元素的方式才会导致错误。】

方法：

append insert del pop栈顶元素 pop(任意位置) remove(值）【方法remove()只删除第一个指定的值。如果要删除的值可能在列表中出现多次，就需要使用循环来判断是否删除了所有这样的值

】使用方法sort()对列表进行永久性排序​降序

使用函数sorted()对列表进行临时排序，

倒着打印列表，方法reverse()）永久性地修改列表元素的排列顺序，

使用函数len ()可快速获悉列表的长度。

处理列表的部分元素——Python称之为切片

[0:3]--0 1 2

[:4]0 1 2 3从头开始

[2:]2 3...到最后（下标是2，是第3个元素）

[：3]前3个

[-3 : ]后3个

[:]整个列表

复制：

list1=list2只是复制了一个变量引用，这两个变量指向同一个列表，一个改变另一个也改变

list1=list2[:]复制了一个副本，指向不同的内存，一个改变另一个不变

列表查找

列表增加

1.append合并增加

#列表
#1.1增加
name_list=['Tom','Lily','ROSE']
# name_list.append('xiaoming')
# print(name_list)
#['Tom', 'Lily', 'ROSE', 'xiaoming']直接写入到结尾 说明列表是一个可变类型
 name_list.append(['xiao','zhan'])
 print(name_list)
#['Tom', 'Lily', 'ROSE', ['xiao', 'zhan']]
#注意点       如果append()追加的数据是一个序列，则追加整个序列到列表

2.extend 拆分增加

#1.2 extend拆分增加
name_list=['Tom','Lily','ROSE']
#name_list.extend('yangyang')
print(name_list)
#['Tom', 'Lily', 'ROSE', 'y', 'a', 'n', 'g', 'y', 'a', 'n', 'g']
name_list.extend(['gongjun','zhehan'])
print(name_list)
#['Tom', 'Lily', 'ROSE', 'gongjun', 'zhehan']
#extend():列表结尾追加数据，如果数据是一个序列，则将这个序列的数据逐―添加到列表

3.insert指定位置新增

#1.3 insert指定任意位置插入
name_list=['Tom','Lily','ROSE']
#               位置下标 数据
name_list.insert(1,'test')
print(name_list)
#['Tom', 'test', 'Lily', 'ROSE']

列表删除

1.1 del删除整个列表或者根据下标进行删除

#1.1.2  del删除指定下标的数据
name_list=['Tom','Lily','ROSE']
del name_list[0]
print(name_list)
#['Lily', 'ROSE']

1.2pop根据下标删除，并返回被删除的值

#2.1 pop 删除指定下标数据，并返回被删除的数据 默认删除最后一个数据
name_list=['Tom','Lily','ROSE']
#pop_n=name_list.pop()
#print(pop_n)#ROSE
print(name_list)#['Tom', 'Lily']
pop_n=name_list.pop(0)
print(name_list)#['Lily', 'ROSE']

1.3remove根据数据值进行删除

#1.3remove根据数据值删除
name_list=['Tom','Lily','ROSE']
name_list.remove('Lily')
print(name_list)#['Tom', 'ROSE']

1.4 clear清空列表 变成空列表

#clear清空列表
name_list=['Tom','Lily','ROSE']
name_list.clear()
print(name_list)#[]

列表修改

1.1修改制定下标的数据

#修改
#1.1修改制定下标的数据
name_list=['Tom','Lily','ROSE']
name_list[1]='hhhh'
print(name_list)#['Tom', 'hhhh', 'ROSE']

1.2逆置数据 

#逆序
name_list.reverse()
print(name_list)
#['Tom', 'hhhh', 'ROSE']
#['ROSE', 'hhhh', 'Tom']
list1=[1,2,3,4,5,6]
list1.reverse()
print(list1)
#[6, 5, 4, 3, 2, 1]

1.3排序

#3.sort()排序  默认升序
list2=[1,2,3,4,5]
list1.sort()
print(list2)
#[1, 2, 3, 4, 5]默认升序
list2.sort(reverse=True)
print(list2)
#[5, 4, 3, 2, 1]降序

列表的复制

.copy() 数据来源不易，为了不破坏原始的数据，做一个数据的副本，再做删除操作

#4列表的复制cooy
lis3=list2.copy()
print(list2)
#[5, 4, 3, 2, 1]
print(lis3)
#[5, 4, 3, 2, 1]

列表的循环遍历

依次打印列表中的数据 while循环

name_list= ['Tom','Lily','ROSE']
i=0
while i<len(name_list):
    print(name_list[i])
    i+=1
# Tom
# Lily
# ROSE

for循环

#for循环
for i in name_list:
    print(i)
#Tom
# Lily
# ROSE

 

元组的常见操作

元组的定义

列表非常适合用于存储在程序运行期间可能变化的数据集。列表是可以修改的，这对处理网站的用户列表或游戏中的角色列表至关重要。然而，有时候你需要创建一系列不可修改的元素，元组可以满足这种需求。Python将不能修改的值称为不可变的，而不可变的列表被称为元组。元组是只读列表。

元组看起来犹如列表，但使用圆括号而不是方括号来标识。定义元组后，就可以使用索引来访问其元素，就像访问列表元素一样。

字典

字典、列表是可变类型，字符串、元组不可

dict3={'name':'Tom','age':10,'gender':'男'}
#修改
dict3['name']='rose'
#增添
dict3['rose']='star'
#删除单个属性
del dict3['age']
#删除整个
del dict3
#查找
dict1={'rrr':"ddd",'www':9}
dict1['rrr']
dict1.get('www',0)
#清空字典--变成空字典
dict3.clear()
print(dict3)

 

字典的循环遍历

dict3={'name':'Tom','age':10,'gender':'男'}
#遍历字典
print('key:')
for key in dict3.keys():
    print(key)
'''key:
name
age
gender'''

print('value:')
for value in dict3.values():
    print(value)
'''value:
Tom
10
男'''

print('item:')
#键值对的拆包
#xx.items()返回可迭代对象，内部是元组，元组有两个数据 数据1 是字典的key,数据2是字典的value
for key,value in dict3.items():
    print(f'{key}={value}')
'''item:
name=Tom
age=10
gender=男'''

创建集合

创建集合使用({}或set()，但是如果要创建空集合只能使用set()，因为用来创建空字典。

集合常见操作方法

增加数据

因为集合有去重功能，所以，当向集合内追加的数据是当前集合已有数据的话则不进行任何操作。

s1={10,20}
#1.集合是可变类型的

#add增加单一数据到集合中
s1.add(100)
print(s1)
#{100, 10, 20}集合是无序的，add可能会增加到任何一个位置
s1.add(100)#集合有去重功能，如果追加已有数据，则什么操作都不做

#update增加一个数据序列到原集合中
s2={1,2}
s2.update([10,20,30,30])
print(s2)
#{1, 2, 10, 20, 30}

删除数据

#删除集合中的数据
s1={10,202,30,40,50}

#remove()：删除指定数据：如果数据不存在报错
s1.remove(10)
print(s1)
s1.remove(10)#KeyError: 10

#discard()删除指定数据，如果数据不存在不报错
s1.discard(202)
print(s1)
s1.discard(202)

#pop()随机删除集合中的数据，并返回这个数据
del_num=s1.pop()
print(del_num)#40
print(s1)

查找数据

in:判断数据在集合序列
not in:判断数据不在集合序列

推导式（为了化简代码）

列表推导式

字典推导式

集合推导式
一.列表推导式
作用:用一个表达式创建一个有规律的列表或控制一个有规律列表。列表推导式又叫列表生成式。

#列表推导式-----创建或控制有规律的列表

#需求︰创建一个0-10的列表

#1.1创建空列表
#1.2循环有规律的数据写入到列表中
list1=[]
i=0
while i<10:
    list1.append(i)
    i+=1
print(list1)


#for循环的实现
list2=[]
for i in range(10):
    list2.append(i)
print(list2)

#列表推导式实现
list3=[i for i in range(10)]
#      *  for循环的左边 也就是i是我们返回的值
print(list3)#[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
#带if的列表推导式
#创建0-10的偶数列表
list4=[i for i in range(0,10,2)]
print(list4)#[0, 2, 4, 6, 8]
list5=[i for i in range(10) if i%2==0]
print(list5)#[0, 2, 4, 6, 8]
names=['jdd','ll','ppp','dd','oo']
names_3=[i for i in names if len(i)>2]
print(names_3)#['jdd', 'ppp']

#多个for循环实现列表推导式
#需求:创建列表如下:
#[(1，0)，(1，1)，(1，2)，(2，0)，(2，1)，(2，2)]
list6=[(i,j) for i in range(1,3) for j in range(3)]
print(list6)
#[(1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]

#字典推导式
#作用：快速合并列表 或 提取字典中目标数据

#创建字典 key是1-5的数字，value是这个数字的平方
dict1={i:i**2 for i in range(1,5)}
print(dict1)#{1: 1, 2: 4, 3: 9, 4: 16}

#将两个列表合并为一个字典
lis1=['name','age','gender']
lis2=['Tom',18,'male']
dict2={lis1[i]:lis2[i] for i in range(len(lis1))}
print(dict2)#{'name': 'Tom', 'age': 18, 'gender': 'male'}

#提取字典中目标数据
#提取电脑数量大于200的字典数据
counts = { 'MBP': 268,'HP': 125,'DELL': 201,'Lenovo': 199, 'acer ': 99}
count1={key:value for key,value in counts.items() if value>=200}
print(count1)#{'MBP': 268, 'DELL': 201}

#集合推导式
#需求:创建一个集合，数据为下方列表的2次方。
lis3=[1,1,2]
set1={i**2 for i in lis3}
print(set1)#{1, 4}集合有数据去重功能

函数的使用步骤

2.1定义函数

2.2调用函数

拆包

https://blog.csdn.net/wzyaiwl/article/details/83079700拆包

https://www.cnblogs.com/bingabcd/p/6671368.html位置参数、关键字参数

#拆包
#对元组进行拆包
def nums():
    return 100,200
j_nmus=nums()
print(j_nmus)
#(100, 200)

a,b=nums()
print(a,b)
#100 200

#对字典进行拆包
dict3={'name':"Tom",'age':19}
a,b=dict3
#取出的是key
print(a)
#name

print(b)
#age
#取出的是value
print(dict3[a])
#Tom

print(dict3[b])
#19

递归

#递归
def digui(num):
    if num==1:
        return 1
    return num+digui(num-1)

sum=digui(4)
print(sum)#10

三、lambda表达式/匿名函数

3.1 l ambda的应用场景
如果一个函数有一个返回值，并且只有一句代码，可以使用lambda简化。（简化了代码量，节省了内存的开销）

3.2 lambda语法

lambda 参数列表︰表达式

注意
lambda表达式的参数可有可无，函数的参数在lambda表达式中完全适用。

lambda表达式能接收任何数量的参数但只能返回一个表达式的值。

#lambda表达式或者匿名函数
#1.只有一行代码且只有一个返回值的函数

def f1(n):
    return n**2
print(f1(3))#9

#lambda 表达式
#lambda 参数列表：表达式

#返回平方
f=lambda n:n**2
print(f)#0x00000239281BE9D0返回内存地址
#如果想要得到返回值，需要调用函数
print(f(3))#9

#计算和
f2=lambda a,b:a+b
print(f2(3,4))#7

#无参数
f3=lambda :100
print(f3())#100

#一个参数
f4=lambda a:a
print(f4('hello'))

#默认参数（缺省参数)
f5=lambda a,b,c=100:a+b+c
#c没有传递参数，就默认是100
print(f5(10,20))#130
#c传递参数参数30，就不用默认，用30
print(f5(10,20,30))#60

#可变参数(处理不定长参数)---*args返回元组---未命名 位置参数
f6=lambda *args:args
print(f6(10,20,30))#(10, 20, 30)
#注意这里的可变参数传入到lambda之后，返回值为元组

#可变参数--**kwargs返回的是字典----命名的 关键字参数
f7=lambda **kwargs:kwargs
print(f7(name='Tom'))#{'name': 'Tom'}
print(f7(name='Tom',age=16,sex='female'))
#{'name': 'Tom', 'age': 16, 'sex': 'female'}

#lambda的应用
#1 带判断的lambda  返回两个值中较大的数
fn1=lambda a,b:a if a>b else b
print(fn1(100,500))#500\

#2 列表数据按字典key的值排序
students=[
    {'name':'Tom','age':20},
    {'name':'ROSE','age':19},
    {'name':'Jack','age':22}
]
#按name值升序排列
students.sort(key=lambda x:x['name'])
print(students)
#[{'name': 'Jack', 'age': 22}, {'name': 'ROSE', 'age': 19}, {'name': 'Tom', 'age': 20}]

#按name值降序排列
students.sort(key=lambda x:x['name'],reverse=True)
print(students)
#[{'name': 'Tom', 'age': 20}, {'name': 'ROSE', 'age': 19}, {'name': 'Jack', 'age': 22}]

四、高阶函数--化简代码，增加函数的灵活性--将函数作为参数传入

把函数作为参数传入，这样的函数称为高阶函数，高阶函数是函数式编程的体现。函数式编程就是指这种高度抽象的编程范式。

函数式编程大量使用函数，减少了代码的重复，因此程序比较短，开发速度较快。

#高阶函数---把函数作为参数传递

#对两个整数求平均值再求和

#方法一
def add_sum(a,b):
    return abs(a)+abs(b)

res=add_sum(-1,2)
print(res)

#方法二
def sum(a,b,f):
    return f(a)+f(b)
res=sum(-1,2,abs)
print(res)

#注意:两种方法对比之后，发现，方法2的代码会更加简洁，函数灵活性更高。

4.1常见的内置高阶函数

#常见内置高阶函数 ---map
list1=[1,2,3,4]
#准备函数
def func(x):
    return x**2
#调用map   把func函数作用到list1中
res=map(func,list1)
print(list(res))#转化成list
#[1, 4, 9, 16]

#reduce---每次累加和
#1.reduce(fn,iter)

   # 功能： 用fn对iter里面的第一个和第二个元素进行运算，将得到的结果和第三个元素用 fn函数运算，最后得到一个结果。
   #
   #             直到序列中的元素全部参与运算
from functools import reduce
list1=[1,2,3,4,5]
def func(a,b):
    return a+b
#调用reduce
res=reduce(func,list1)
print(res)#15

# 方式二
result2 = reduce(lambda x, y: x + y, list1)
print(result2)#15

# 将数字列表中的所有元素合成一个数字        [1,2,3,4,5]---------> 12345
def func(a,b):
    return a*10+b
res=reduce(func,list1)
print(res)#12345

# 方式二
result4 = reduce(lambda x, y: x*10+ y, list1)
print(result4)#12345

#3.内置函数  filter()
#filter(func, Ist)函数用于过滤序列,过滤掉不符合条件的元素,返回一个filter对象。如果要转换为列表，可以使用list()来转换。
list2=[1,2,3,4,5,6,7,8,9,10]
def func(x):
    return x%2==0
#将func函数作用到list2中,把满足条件的过滤出来
res=filter(func,list2)
print(list(res))#[2, 4, 6, 8, 10]

str与int互换

a='124'
b=int(a)
print(a)
print(type(a))
print(b)
print(type(b))
# 124
# <class 'str'>
# 124
# <class 'int'>

文件操作

总结︰文件操作的作用就是把一些内容(数据)存储存放起来，可以让程序下一次执行的时候直接使用，而不必重新制作一份，省时省力。

+可读可写   b二进制 w+与b+的区别就是特性遵循前面的主模式w或r。a的指针在结尾,w和r在开头

#1.打开文件
#打开的文件名字  打开模式：只读r，写入w，追加a
# w如果文件不存在，先创建，如果存在，w先清空再写入，a直接末尾追加，r文件不存在就报错,只读模式下不可写入
f=open('G:\PyCharmSpace\love.txt','r+')#r+读写
#2.写
#对象.write('内容')
f.write('shsfsg')#会覆盖原来的内容


#读
#1文件对象.read(num)
# num表示要从文件中读取的数据的长度（单位是字节)，如果没有传入num
# 那么就表示读取文件中所有的数据。
#文件内容如果换行，底层有\n，会有字节占位，导致read书写参数读取出来的眼睛看到的个数和参数值不匹配
#print(f.read())#shsfsg
#print(f.read(6))

# readlines()
# readlines可以按照行的方式把整个文件中的内容进行一次性读取，并且返回的是一个列表，其中每一行的数据为一个元素。
#content=f.readlines()
#print(content)#\n也会被读取
#['我爱你\n', 'i love you\n', '我爱你\n', 'i love you\n', '我爱你\n', 'i love youshsfsgshsfsgshsfsgshsfsg']

#readline()—次读取一行内容。
c1=f.readline()#读取第一行
print(c1)
c2=f.readline()#继续读取第二行
print(c2)


#3.关闭文件
f.close()