Python基础语法
操作符** 和 操作符 //的使用
a = 2 ** 3
b = 3 // 2
c = 3 / 2
print(a)
print(b)
print(c)
- 在python中整数除以整数会保留小数部分,
- 在python中//表示整除,默认向下取整(就是向数轴左边取整)
- 在python中**表示次方
- 在 Python 中, 0 不能作为除数!
python的设计理念是:解决一个问题,只提供/采用一种解释方案
a = 10
print(type(a))
a = 2.0
print(type(a))
a = 'hello'
print(type(a))
a = True
print(type(a)) 
- a = 10意思是开闭一段空间,再将10放入这段空间, 用a来标识这段空间中的10
- 在python中内置类型有:int,float,str(字符串类型),它不像C++/Java有long long,short那些类型,
- 在python中int能表示的数据范围是无穷的
print格式化控制
e = "My name is 'tangzhong'"
print(e)
a = 10
print(f"a = {a + 10}")
# 我们希望把数字和字符串混在一起来打印~- python中要求使用引号把一系列的字符引起来就构成了字符串,这里的引号使用单引号或者双引号都可以
- 如果出现了字符串嵌套的问题,那么这两个字符串嵌套就可以采用不同的引号区分,甚至是```
- 通过print(f " ")格式化控制能把数字和字符串混在一起打印
input输入
a = int(input('请输入第一个整数: '))
b = input('请输入第二个整数: ')
print(type(a))
print(type(b))
b = int(b)
print(type(b))
c: int = a
print(type(c))
print(f'a + b = {a + b}')
- input返回的是str类型,默认输入的字符串,且字符和数字是不能直接加减的
- 在python中可以通过a = int(a)一样转换类型,当然也是可以指定默认类型的,就像上面的c: int = a一样
逻辑运算符 and or not
a = 10
b = 20
c = 30
print(a < b < c)
print(a < b and b < c)
print(a > b or b < c)
print(not a < b)- python中的and or not 这个三个逻辑运算符,就等价于C/C++中的&& || !这三个逻辑运算符
案例:交换两个变量的值
a, b = 10, 20
# 使用多元赋值, 直接一步到位完成交换.
a, b = b, a
print(a, b)
操作符++和--
a = 10
++a
print(a)
--a
print(a)
- 在python中是不支持++和--这样的自增或自减运算符,
语句的连续写入
a = 'hello'
b = 'world'
print(a + b)
# a = 'hello'
# b = 10
# print(a + b)
a = 10
b = 5.5
print(a + b)
a = 10
b = False
print(a + b)
a = 10; print(a) 
- 如果把多个语句写到一行,那么在这些语句之间,都需要加上分号,但是不推荐
选择语句
choice = input("输入 1 表示愿意认真学习, 输入 2 表示躺平摆烂: ")
if choice == '1':
print('你能够找到好工作')
elif choice == '2':
print("你可能毕业就失业了")
else:
# 除了 1 和 2 其他的情况都算非法情况
print("您的输入有误!")- 在python中if的条件判断语句没有括号,结束标志是:
a = input("请输入第一个整数: ")
b = input("请输入第二个整数: ")
if a == '1':
if b == '2':
print("aaa")
print("bbb")
print("ccc")
- 在Python中的代码段是靠缩进区分的,是没有{ }的
pass语句
a = input("请输入一个数字: ")
if a != '1':
# 啥都不做
pass
else:
print('hello')- 这里没有pass就会报错,pass表示空语句,它的作用就是占位
循环语句for
# 打印 1-10
for i in range(1, 11):
print(i)
# 打印 2, 4, 6, 8, 10
for i in range(2, 12, 2):
print(i)
# 打印从 10 到 1
num = 10
while num >= 1:
print(num)
num -= 1
for i in range(10, 0, -1):
print(i)- range是一个内建函数,起到的效果就是得到一个"可迭代对象",
- range(begin,end) => [begin,end),它的范围是左闭右开区间
- range的第三个参数,表示步长,正数是从左向右开始,负数是从右向左开始
# 假设我要吃 5 个包子
for i in range(1, 6):
if i == 3:
# 发现第三个包子, 有一只虫~
continue
print(f'吃第 {i} 个包子')
# 还是要吃 5 个包子
for i in range(1, 6):
if i == 3:
# 发现第三个包子, 有半只虫
break
print(f'吃第 {i} 个包子')
- 在python中是支持continue和break的
案例:随机数的生成
import random
import time
# 让系统休眠一秒
time.sleep(1)
# 生成随机数
point = random.randint(1, 3)
print(point)- 这里的import random相当于C语言中的头文件,randint相当于C语言当中的库函数
函数-def
# 定义一个求和函数
def calcSum(beg, end):
theSum = 0
for i in range(beg, end + 1):
theSum += i
print(theSum)
calcSum(1, 100)
calcSum(300, 400)
calcSum(1, 1000)- def 函数名 (形参列表):
- 函数体需要有缩进(带有缩进的代码,才是函数内部的语句)
- 在python中函数定义要写在前面,函数调用写在后面,先定义,后调用
def add(x, y):
return x + y
print(add(10, 20))
print(add(1.5, 2.5))
print(add('hello', 'world'))
# print(add(10, 'hello'))
- 在python中函数参数的类型没有要求,只要保证传入的参数类型,在函数体里面能够支持对应的运算操作,即可
def getPoint():
x = 10
y = 20
return x, y
a, b = getPoint()
_, b = getPoint()- 在python中函数的返回值可以有多个,如果不接收的话可以用_代替
global关键字
x = 10
def test():
global x
# 修改全局变量
x = 20
test()
print(f'x = {x}')
- 在函数访问一个变量的时候,会先在局部变量中查找,如果没找到,就会查找上一层的作用域,
- 而为了让函数里面知道x是个全局变量,就需要使用global关键字先声明一下
def add(x, y, debug=False):
if debug:
print(f'x = {x}')
return x + y
result = add(10, 1,True)
print(result)- 在python中是支持缺省值的,
def test(x, y):
print(f'x = {x}')
print(f'y = {y}')
test(x=10, y=20)
test(y=100, x=200)- 在python中可以按照形参的名字来进行传参,这种方式叫关键字传参,它可以无视形参和实参之间的顺序
列表 - list
# 1. 直接使用字面值来创建
a = []
print(type(a))
# 2. 使用 list() 来创建
b = list()
print(type(b))
# 3. 可以在创建列表的时候, 在 [ ] 中指定列表的初始值.
# 元素之间使用 , 来分割
a = [1, 2, 3, 4]
print(a)
# 4. 可以在同一个列表里放不同类型的变量
a = [1, 'hello', True, [4, 5, 6]]
print(a) 
- 这里的[ ]在python中叫列表,等价于C语言的数组,下标也是从0开始访问
- 列表之所以支持存不同类型的,是因为底层是存储的地址
内建函数 - len
# 8. 可以使用内建函数 len 来获取到列表的长度(元素个数) , 和字符串类似.
a = [1, 2, 3, 4]
print(len(a))
# 9. Python 中的下标, 其实还可以写成负数!!
a = [1, 2, 3, 4]
print(a[len(a) - 1])
# -1 就是倒数第一个元素!
print(a[-1])- 在python中可以这样写a[-1],表示最后第一个元素
切片操作 - :
# 1. 切片操作的基本使用
a = [1, 2, 3, 4]
print(a[1:3])
# 2. 使用切片的时候, 省略边界.
a = [1, 2, 3, 4]
# 省略后边界, 意思是从开始位置, 一直取到整个列表结束.
print(a[1:])
print(a[:2])
print(a[:-1])
print(a[:])
# 3. 带有步长的切片操作
a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
print(a[::2])
print(a[1:-1:2])- 切片操作的范围是前闭后开的,第三个参数表示步长
- 列表中的切片操作是一个比较高效的操作,进行切片的时候,只是取出了原有列表中的一个部分,并不涉及"数据的拷贝"
列表的访问
# 1. 使用 for 循环来遍历列表
a = [1, 2, 3, 4, 5]
for elem in a:
elem = elem + 10
print(a)
# 2. 使用 for 循环遍历, 通过下标的方式.
a = [1, 2, 3, 4, 5]
for i in range(0, len(a)):
# print(a[i])
a[i] = a[i] + 10
print(a)
# 3. 使用enumerate变量
a = ["早上好", '中午好', '晚上好']
for index, val in enumerate(a):
print(index, val)
- 使用enumerate 可以打印出序号
列表的插入
# 1. 使用 append 往列表末尾新增一个元素.
a = [1, 2, 3, 4]
a.append(5)
print(a)
b = [5, 6, 7, 8]
b.append('world')
print(b)
# 2. 还可以使用 insert 方法, 往列表的任意位置来新增元素~
a = [1, 2, 3, 4]
a.insert(1, 'hello')
a.insert(100, 'hello')
print(a)
- 列表的新增可以使用append或者insert内建函数,
列表的判定
a = [1, 2, 3, 4]
print(1 in a)
print(10 in a)
print(1 not in a)
print(10 not in a)
a = [1, 2, 3, 4]
print(a.index(2))
print(a.index(3))
- 使用 in 来判定某个元素是否在列表中存在.
- 使用 index 方法, 来判定, 当前元素在列表中的位置.返回下标.
列表的删除
a = [1, 2, 3, 4]
a.pop()
print(a)
a = [1, 2, 3, 4]
a.pop(1)
print(a)
a = ['aa', 'bb', 'cc', 'dd']
a.remove('cc')
print(a)
- 使用 pop 删除列表中的最末尾的元素.
- 使用 pop 还能删除任意位置的元素. pop 的参数可以传一个下标过去.
- 使用 remove 方法, 可以按照值来进行删除.
列表的拼接
a = [1, 2, 3, 4]
b = [5, 6, 7, 8]
c = b + a
print(c)
print(a)
print(b)
a = [1, 2, 3, 4]
b = [5, 6, 7, 8]
a.extend(b)
print(a)
print(b)
a = [1, 2, 3, 4]
b = [5, 6, 7, 8]
a += b
print(a)
print(b)- 使用 + 针对两个列表进行拼接.
- 使用 extend 来进行拼接.a.extend(b)不涉及拷贝
- 使用 += 来进行拼接,a += b涉及拷贝
元组
# 1. 创建元组
a = ()
print(type(a))
b = tuple()
print(type(b))
# 2. 创建元组的时候, 指定初始值.
a = (1, 2, 3, 4)
print(a)
# 3. 元组中的元素也可以是任s意类型的.
a = (1, 2, 'hello', True, [])
print(a)-
元组除了内部元素无法被修改之外,其他的一系列操作和列表一样
字典
# 1. 创建字典
a = {}
print(type(a))
b = dict()
print(type(b))
# 2. 创建字典的同时设置初始值.
a = {
'id': 1,
'name': 'zhangsan',
}
print(a)
- 字典里面存放的是键值对,这里的id是键(key),1是值(value)
- 键值对的概念有点像哈希表中的映射
字典的访问
a = {
'id': 1,
'name': 'zhangsan'
}
print('id' in a)
print('classId' in a)
print('id' not in a)
print('classId' not in a)
a = {
'id': 1,
'name': 'zhangsan',
100: 'lisi'
}
print(a['id'])
print(a['name'])
print(a[100])
- 使用 in 来判定某个 key 是否在字典中存在.in 只是判定 key 是否存在, 和 value 无关!
- not in 来判定 key 在字典中不存在
- 使用 [ ] 来根据 key 获取到 value
字典的插入和删除
a = {
'id': 1,
'name': 'zhangsan'
}
a['score'] = 90
print(a)
a['score'] = 100
print(a)
a.pop('name')
print(a)
- 如果 key 不存在,往里写入,相当于新增键值对
- 如果 key 存在,往里写入,则相当于根据 key 修改 value
字典的遍历
# 直接使用 for 循环来遍历字典
a = {
'name': 'zhangsan',
'id': 1,
'score': 90
}
for key in a:
print(key, a[key])
for key, value in a.items():
print(key, value)
print(a.keys())
print(a.values())
print(a.items()) 
- keys 获取到字典中的所有 key
- values 获取到字典中的所有 value
- items 获取到字典中的所有 键值对
对字典的补充说明
- python字典不是一个单纯的哈希表,它做了特殊处理,保证了遍历出来的顺序和插入的顺序是一致的
字典和列表的差异性
- 对于字典来说,使用 in 或者 [ ] 来获取value进行增删查改,都是非常高效的操作!!
- 对于列表来说,使用 [ ] 是比较高效的
文件
# 使用 open 打开一个文件.
f = open('./record.txt', 'r')
print(f)
print(type(f))
f.close()
- 打开文件使用open,它的返回值是一个文件对象
- 打开文件之后,一定要记得使用close关闭,
获取程序能打开文件的个数
flist = []
count = 0
while True:
f = open('./record.txt', 'r')
flist.append(f)
count += 1
print(f'打开文件的个数: {count}')
- 因为一个系统的资源是有限的,所以一个程序能打开的文件个数,也是有上限的!
文件的打开
f = open('./record.txt', 'w')
f.write('hello')
f.close()
f = open('./record.txt', 'w')
f.write("1111\n")
f.close()
f = open('./record.txt', 'a')
f.write("2222")
f.close()
- 写文件不能用 r 方式打开,写到文件中,是会发生异常报错的
- 如果文件对象已经被关闭, 系统中和该文件相关的内存资源已经释放了.强行去写, 就会出异常.
文件的遍历
f = open('./record.txt', 'r', encoding='utf8')
result = f.read(3)
print(result)
f.close()
# 2. 更常见的需求, 是按行来读取~~
f = open('./record.txt', 'r', encoding='utf8')
for line in f:
print(f'line = {line}', end='')
f.close()
f = open('./record.txt', 'r', encoding='utf8')
lines = f.readlines()
print(lines)
f.close()
- 使用 read 来读取文件内容. 指定读几个字符.
- encoding='utf8'表示使用utf-8编码,如果不写默认使用gbk编码,这个编码是不支持中文的,会报错,
- end=' '表示结尾什么输出空格,如果不写默认结尾输出\n
- readlines直接把整个文件所有内容都读出来, 按照行组织到一个列表里.
上下文选择器 - with as
def func():
with open('./record.txt', 'r', encoding='utf8') as f:
pass
# 代码执行逻辑- 这里的with和as就是上下文选择器,当with对应的代码块执行结束,就会自动执行f的close,
- 防止程序员自己忘记关闭文件,而浪费资源所出现的
使用库
import [模块名]
-
使用 import 可以导入标准库的一个 模块
-
所谓 "模块" , 其实就是一个单独的 .py 文件.使用 import 语句可以把这个外部的 .py 文件导入到当前 .py 文件中, 并执行其中的代码.
-
案例:计算两个日期之间差了多少天 - datetime
import datetime as dt
date1 = dt.datetime(year=2012, month=2, day=14)
date2 = dt.datetime(year=2016, month=2, day=3)
print(date2 - date1)
-
使用 import 语句导入标准库的 datetime 模块
案例:翻转单词顺序 - reverseWord
def reverseWords(s: str):
tokens = s.split()
tokens.reverse()
return ' '.join(tokens)
print(reverseWords("I am a student."))
- 使用 str 的 split 方法进行字符串切分, 指定 空格 为分隔符. 返回结果是一个列表.
- 使用列表的 reverse 方法进行逆序.
- 使用 str 的 join 方法进行字符串拼接. 把列表中的内容进行合并.
案例:旋转字符串 - rotateString
def rotateString(s, goal):
if len(s) != len(goal):
return False
return goal in (s + s)
print(rotateString("abcde", "edcba")) 
- 使用 len 求字符串的长度. 如果长度不相同, 则一定不能旋转得到.
- 将 s 和 自己 进行拼接, 然后直接使用 in 方法来判定 goal 是否是 s + s 的子串
案例:统计给定字符串前缀的字符串数目 - countPrefixes
def countPrefixes(words: list, s: str):
count = 0
for word in words:
if s.startswith(word):
# s 是以 word 开头
count += 1
return count
print(countPrefixes(['a', 'b', 'c', 'ab', 'bc', 'abc'], 'abc'))
print(countPrefixes(['a', 'a'], 'aa'))
- 依次遍历 words 中的字符串
- 直接使用字符串的 startswith 方法即可判定当前字符串是否是 s 的前缀
案例:文件查找工具 - os
-
输入要查找的路径, 输入要搜索的文件名(一部分)
-
自动的在指定的路径中进行查找~
import os
inputPath = input('请输入要搜索的路径:')
pattern = input('请输入要搜索的关键词:')
for dirpath, _, filenames in os.walk(inputPath):
for f in filenames:
if pattern in f:
print(f'{dirpath}/{f}')
-
使用 os.walk 即可实现目录的递归遍历.
-
os.walk 返回一个三元组, 分别是 当前路径 , 当前路径下包含的目录名 (多个), 当前路径下包含的文件名 (多个)