本文详细介绍了Python的基础语法，包括注释的含义和作用、变量与数据类型的定义、算数和比较运算符、逻辑运算符、赋值运算符，以及输入输出的使用。此外，还讲解了流程控制结构、高级数据类型如字符串、列表、元组和字典，以及函数的定义、参数分类和返回值。最后，讨论了全局和局部变量以及Python的内置函数和类型转换功能。
目录
1-注释、变量、输入输出
1.1-注释：
1.1.1-含义
编写程序时，写程序的人给一个语句、程序段、函数等的解释或提升
1.1.2-作用
可以起到提示的作用，对所写的代码有解释的作用，提高代码的可读性、提高开发效率，
尤其对大型项目或者团队项目有重要意义
还可以对代码进行调试
1.1.3-注释类型
1.单行注释#
快捷键：Ctrl+/
一般用于对一条语句的解释说明
2.多行注释：
''' xxxx'''或者""" xxx """
一般用于在函数内部，用于提醒函数作用，已经返回return的值
在python 语句中，有两句特殊的注释：
#!/suer/bin/python3 ·······这是Python的解析路径
#--coding=utf-8--
这是指定的编码格式，值得注意的是Python3默认采用的编码就是utf-8，所以不需要加这段代码，如果需要兼容Python2版本，一般都要加上这段代码。
这两句注释一般都会放在行首
1.2-变量与数据类型
1.2.1-变量
可变的量，可以用来存储数据，可以多次赋值
在Python中，一般是变量+逻辑通过Python解释器的作用来实现软件的功能
变量是一段有名字的连续存储的空间，我们可以通过定义变量来申请并命名这样的存储空间，并通过变量的名字来使用这段空间
1.2.2-定义变量：
a=10
1.2.3-变量的命名规则
Python关键字不能作为变量名
变量的命名不能以数字来开头
变量的命名区分大小写
1.2.4-变量的命名规范
*见名知意，尽量使用有语义的单词命名。 如使用password作为密码，username作为姓名
*小驼峰式命名法：第一个单词首字母小写其他单词首字母大写，如userName
*大驼峰式命名法：全部单词首字母都用大写，如UserName
*下划线命名法：每个单词用_下划线连结，如user_name
1.3-算数和比较运算
+、-、*、/、%、**、//
比较运算符
== 等于
！= 不等于
> 大于
< 小于
>= 大于等于
<= 小于等于
1.4-逻辑运算符
and x and y x,y同为真，结果为真，如果一个为假，则结果为假
or x or y x，y有一个为真，则结果为真，全部为假，则结果为假
not not x 取反，如果x为真，则结果为假，如果x为假，则结果为真
优先级：（）>not>and>or
1.5-赋值运算符
+=
-=
*=
/=
%= 取模
**= 幂赋值运算符
//=取整赋值运算符 等同于 c = c // a
1.6-Python的输入与输出
1.6.1-输出
1）.Python有一个简单的字符串格式化方法，使用%做站位符。%后面跟的是变量的类型
例如：
name='张杨'
classpro='重邮一班'
print('我的名字是%s,来自来自【%s】'%(name,classpro))
#\n 具有换行效果
2）. .format()形式
print("姓名：{} 年龄是：{}".format(name,age))
1.6.2-输入
input
name=input("请输入你的姓名:")
2-流程控制结构
流程：计算机代码执行的顺序
流程结构：对计算机代码执行的顺序进行有效的管理，只有流程控制才能实现现实在开放当中的业务逻辑
2.1-流程控制的分类：
1.顺序流程：就是代码一直自上而下的执行结构，也就是Python默认的流程
2.选择流程/分支流程：根据在某一步的判断，有选择的去执行相应的逻辑的一种结构
2.1单分支
if 条件表达式:
.......
pass
2.2双分支
if 条件表达式:
.......
pass
else:
.......
.......
2.3多分支
特征：
1.只要满足其中一个分支，就会退出本层if语句结构
【必定会执行其中一个分支】
2.至少有两种情况来选择
if 条件表达式:
.......
pass
elif 条件表达式:
...........
...
elif 条件表达式:
...........
...
...
else:
.......
.......
条件表达式：比较运算符/逻辑运算符/
2.4嵌套
作用：可以在大范围进行更细致的筛选
score=int(input('请输入你的学分：'))
grade=int(input('请输入你的成绩'))
if score>10:
if grade>=80:
print('恭喜你可以升班')
else:
print('很遗憾，成绩不达标')
else:
print('表现太差')
3.循环流程：在一定的条件下，一直重复的去执行某段代码的逻辑
while
语法特点：
1.有初始值
2.条件表达式
3.变量【循环体内技术变量】的自增自减，否则就会死循环
使用条件：循环次数不确定，是依靠循环条件来结束
目的：为了将相似或者相同的代码变得更加简洁，使代码可以重复使用
条件表达式:
一条条Python代码
一条条Python代码
一条条Python代码
一条条Python代码
......
for ... in 可迭代集合对象:
一条条Python代码
一条条Python代码
一条条Python代码
一条条Python代码
......
语法特点： 遍历操作，依次的取集合容器中的每个值
range：
生成一个数据集合列表
range(起始：结束：步长)
break：
中断，退出循环，满足条件直接结束本层循环
continue:
结束循环，继续下次循环，当continue条件满足时，本次循环剩下的语句将不执行，直接开始下一轮循环
for 和 while 的使用时机
for:适用于已知的循环次数【可迭代对象遍历】
while: 适用于对未知的循环次数 用于判断
3-Python的高级数据类型
序列的概念：一组按顺序排列的值（数据集合）
3.1-Python中存在三种内置的序列类型：
字符串、列表、元组
优点：可以支持索引的切片操作
特征：第一个索引为0，指向的是左端，第一个索引为负数时，指向的是右端
切片：
高级特性：可以根据下标截取序列对象的任意数据部分
使用语法：[起始下标：结束下标：步长]步长默认情况下为1
左闭右开，start<=value<end
倒序输出：print（strMsg[::-1]）
3.1.1-字符串
定义：变量=‘字符串’/“字符串”
关于字符串的操作：
首字母变大写
print('姓名首字母转化大写%s'%name.capitalize())
a=' hello '
去除字符串中的空格
print(a.strip())
删除左边空格
print(a.lstrip())
print(a.rstrip())
复制字符串
b=a#在此只是把a对象的内存地址赋值给了b
print(b)
find查找目标对象在序列对象中的位置，如果没找到返回-1
dataStr='I love Python'
print(dataStr.find('o'))
print(dataStr.index('y'))#检测字符串中是否包含子字符串 返回的是下标值
# index如果没有找到对象的数据 就会报异常，而find函数不会，找不到返回-1
startswith来判断以...为开头
print(dataStr.startswith('I'))
endwhith来判断...为结尾
print(dataStr.endswith("n"))
转换大小写
print(dataStr.lower())
print(dataStr.upper())3.1.2-列表
定义：
list1=[1,2,3,4]
特点：
1.支持增删查改
2.列表中的数据是可编号的【数据项可以变化，内存地址不会改变】
3.用[]来表示列表类型，数据项之间用逗号分隔
注意：数据项可以是任何类型
3.1.3-元组
和列表类似，但元组一但创建就把你修改
#元组的查询
for item in tupleA:
print(item,end=' ')
#统计数据项出现次数
tupleC=(1,1,2,2,2,2,3,4,5,5,5,)
print(tupleC.count(2))3.1.4-字典
字典内保存的元素以键值对的形式存储，为：key：value
创建字典
dictA={'pro':'艺术','school':'北电'}
添加字典数据
dictA['age']=30
dictA['pos']='歌手'
查找
print(dictA['name'])#通过键值获取对应的值
修改
dictA['age']=15'#修改键对应的值
另一种方式：
dictA.update({'age':'32'})
dictA.update({'height':'1.80'})
dictA['school']='香港大学'
获取所有的键
print(dictA.keys())
获取所有的值
print(dictA.values())
获取所有的键值对
print(dictA.items())
for key,value in dictA.items():
print('%s==%s'%(key,value))
删除
del dictA['name']#通过指定键进行删除
排序
print(sorted(dictA.items(),key=lambda d:d[0]))
按照value值排序
print(sorted(dictA.items(),key=lambda d:d[1]))
3.1.5-共有方法
#共有方法+ * in
字符串合并
strA='人生苦短'
strB='我用python'
list 合并
listA=list(range(10))
listB=list(range(11,20))
print(strA+strB)
print(listB+listA)
复制
print(strA*3)#复制三次
in 判断对象是否存在 结果是一个bool值，与if语句结合时可以很有效的利用返回值进行操作
print('人' in strA)
print(9 in listA)
dictA={'name':'peter'}
print('name'in dictA)4-函数
一系列Python语句的组合，可以在程序中运行一次或者多次，具有一定独立功能的代码块
4.1-函数作用：
提高编写效率
使代码的复用最大化以及最小化冗余代码，保证整体代码结构清晰，问题局部化
定义
def 函数名(参数列表):#参数可以是0~n个
函数体[一系列Python语句，表示独立功能]
用法：
def 函数名（）：
代码块
函数的调用：
函数名加()即可调用
本质上就是去执行函数定义里面的代码块，在调用函数之前必须定义4.2-函数参数
函数为人类实现某些特定的功能，进而为了得到实现功能所需要的数据
4.3-参数分类
4.3.1-必选参数
def sum(a,b):#形式参数:只是意义上的一种参数，在定义的时候是不占内存地址的
sum=a+b
print(sum)
pass
#函数调用
sum(20,15)#20 15 实际参数：实参，实实在在的参数，是实际占用内存地址的
#函数调用时，必选参数是必选赋值的4.3.2-默认参数[缺省参数]:始终存在参数列表中的尾部
def sum1(a=20,b=30):#默认参数的值必选在参数中最后的位置
print('默认参数的使用=%d'%(a+b))
pass
#默认参数的调用
sum1(10)#在调用的时候如果未赋值，就会定义函数时给定的默认值4.3.3-可变参数(当参数的个数不确定时使用，比较灵活)
接收的类型是元组类型
def getComputer(*args):
'''
计算累加和
:param args:
:return:
'''
result=0
for item in args:
result+=item
print('result=%d'%result)
getComputer(1,2,3,4,5,6)4.3.4-关键字可变参数
用**来定义
在函数体内，参数关键字是一个字典类型，key是一个字符串
接收的是字典类型
用法：
def keyFunc(**kwargs):
print(kwargs)
也可以是：
def complexFunc(*args,**kwargs):
print(args)
print(kwargs)
pass
注意：
可选参数必须放在关键字可选参数之前
当把字典导入函数中时，字典的名字要加**
4.3.5-函数返回值
概念：函数执行完以后会返回一个对象，如果在函数的内部有return就可以返回实际的值，如果没有返回则是空
返回类型：任意类型 ，返回类型一个取决于return后面的类型
用途：给调用方返回数据
return：
在一个函数体内可以出现多个return值：但是肯定只能返回一个return
如果在一个函数内执行了return，意味着函数就执行完成退出了，return后面的代码语句将不执行
4.3.6-函数的嵌套调用
def fun1():
print('-------------fun1 start---------------')
print('-------------执行代码省略---------------')
print('-------------fun1 end---------------')
pass
def fun2():
print('-------------fun2 start-----------------')
#调用第一个函数
fun1()
print('--------------fun2 end-------------')
pass
fun2()#调用函数25-全局变量
5.1-函数的四种基本类型：
1、无参数，无返回值，一般用于提示信息打印
2、无参数，有返回值，多用于信息采集中，比如获取系统信息
3、有参数，无返回值，多用于在设置某些不需要返回值的参数设置
4、有参数，也有返回值，一般是计算型，需要参数，最终也要返回结果
5.2-局部变量
定义
在函数内部定义的变量(作用域仅仅局限在函数内部)
不同的函数可以定义相同的局部变量，但是各自用各自的 不会参数影响
作用
为了临时的保存数据，需要在函数中定义来存储
5.3-全局变量
在整个文件当中都可以使用的变量，一般定义在函数外面
当全局变量和局部变量都是同一个变量名时，函数会优先使用函数内部定义的变量
如果在函数内部要修改全局变量，必须使用global关键字进行声明
5.4-函数参数引用传值
5.4.1-不可变类型
a=1 a是一个标签，存储的是1的地址，如果值改变，a存储的地址也会改变
5.4.2-可变变量
字典、元组，当内容改变时，id地址不变
在Python当中 万物皆对象，在函数调用的时候，实参的传递就是对象的引用
了解了原理之后，就可以更好的去把控在函数内部数据的处理是否会影响到函数外部的数据变化
参数传递是通过对象的引用来完成
5.4.3-匿名函数
lambda 参数1，参数2:，参数3：执行代码
特点：
使用lambda关键字去创建函数
没有名字的函数
匿名函数冒号后面的表达式有且只有一个，注意：是表达式，不是语句
匿名函数自带return，而且这个return的结果就是表达式计算后的结果
缺点：
lambda 只能是单个表达式，不是一个代码块，它的设计就是为了满足简单函数的场景，它仅仅能封装有限的逻辑，复杂逻辑实现不了，必须使用def来处理
5.4.4-递归函数
定义：通过一个函数在内部不调用其他函数，而是本身的话，这个函数就是递归函数。
必须有一个结束条件(出口)
优点：逻辑简单、定义简单
缺点：容易导致栈溢出，导致内存紧张，甚至内存泄漏
例子：
#递归函数的实现
def factorial(n):
'''
递归实现
:return:
'''
if n==1:
return 1
else:
return n*factorial(n-1)
#递归的调用
print('10的递归{}'.format(factorial(10)))6-内置函数
6-2-内置函数
取绝对值
print(abs(-32))
#round() 对浮点数进行近似值，保留几位小数
print(round(3.66,1))
pow 求次方
print(pow(3,3))#同等于3**3
max 求最大值
print(max([23,523,5646,64,646,6]))
sum 求和
print(sum(range(50)))
eval 动态执行表达式
a,b,c,=1,2,3
print('动态执行的函数=%s'%eval('a+b+c'))
def Test():
print('zhixing')
pass
eval('Test()')#可以调用函数执行6-3-类型转换
#chr() 数字转字符
#bin 转换二进制
#hex 转换十六进制
#list 元组转换为列表
tup=()
li=list(tup)#转换
print(type(tup))
li.append('强制转换成功')
print(li)
列表转换元组
tuplist=tuple(li)
print(type(tuplist))
dict()创建字典
dic=dict(name='小明',age=18)#创建一个字典的过程
print(type(dic))
print(dic)
bytes()转为字节数组，需要用.encode指定编码，
print(bytes('我喜欢Python'.encode('utf-8')))6-4-类型转换函数
all()用于判定给定的可迭代参数ierable中所有元素是否都为TRUE，如果是返回True，否则返回False，除了0，空，FALSE外都算是TRUE
#序列操作 str 元组、list
print(all([]))#True
print(all(()))#True
print(all([1,2,3,False]))#出现False为False
print(all([2,3,4]))
print(all((0,8,7)))#有0位False
any 只要有一个为Ture 则返回Ture
print('-----------any-----------')
print(any([1,3,4,False,0]))
#sorted和sort
li=[32,4,3,5,56]#原始对象
#li.sort()#list的排序方法，直接修改的原始对象
print(li)
print('-----排序之前-----{}'.format(li))
varlist=sorted(li)#可以对所有的可迭代对象进行排序，包括元组
#reverse 用于反向列表中的元素
varlist=sorted(li,reverse=True)
print('-----排序之后-----{}'.format(varlist))
tupArray=(32,4,3,5,56)
varRs=sorted(tupArray)
print(varRs)
zip() 用来打包的，使打包的两个集合的元素一一对应以元组的形式包装
s1=['a','b','c']
s3=[1,2,23,4,45,5,6]
s2=['你','我','他']
print(list(zip(s1)))#[('a',), ('b',), ('c',)]
ziplist=zip(s1,s3)#[('a', 1), ('b', 2), ('c', 23)]
print(list(ziplist))
enumerate()
用于将一个可遍历的数据对象（如列表、元组、或字符串）组合为一个索引序列
同时列出数据和数据下标，一般用于for循环中
listObj=['a','b','c']
for index,item in enumerate(listObj,start=5):
print(index,item)
set集合
set1={1,2,3}
set2={2,3,4}
print(type(set1))
添加操作
set1.add('python')
print(set1)
清空操作
set1.clear()
print(set1)
取差集
set3=set1.difference(set2)
print(set3)
等同于
print(set1-set2)
& 交集操作
print(set1.intersection(set2))
print(set2&set1)
并集操作
print(set1.union(set2))
print(set2|set1)
pop 就是从集合中拿数据并且同时删除
print(set1)
quData=set1.pop()
更新集合
print('更新操作：update')
set1.update(set2)
print(set1)
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
