python基础语法

1、** 在python中表示乘方运算， ** 2即为求平方
2、python中的常见变量类型：

1. 整数（int）
2. 浮点数（float）
   对于浮点数来说，不要使用==来判定是否相等， 因为浮点数会出现很小的误差，造成错误
3. 字符串（str）
   字符串是可以相加的，但是不能让字符串和上面两种类型相加
   并且str是不能进行 - * / 的操作
4. 布尔
   需要注意的是布尔类型取值是两种，并且两种类型都要大写True 和 False

3、动态类型特性
在python中，一个变量的类型，是可以在程序运行的过程中变化的，这点和其他语言不同

4、注释方法
分为# + 后面注释的内容 或者  ''''''   + 注释内容 + '''''' 

5、控制台输出

在python中，使用print函数输出到控制台

print('hello')

num = 10
print(f'num = {num}')

6、通过控制台输入

在Python中使用input函数， 从控制台读取用户的输入

num = 0
num = input('请输入一个整数')
print(f'你输入的整数是{num}')

需要注意的是，input的返回值是用户输入的内容，是字符串类型,如果希望通过输入来进行加法运算， 需要转换类型

a = input('请输入第一个整数')
b = input('请输入第二个整数')

a = int(a)
b = int(b)

print(f'a + b = {a + b}')

7、逻辑运算符

比如and or not 这一系列的运算符被称为逻辑运算符 这几种运算符可以对应c++中的&& || !

8、赋值运算符

= 有两种赋值方式

链式赋值

a = b = 10

多元赋值

a, b = 10, 20

 9、条件语句

（1）if

if expression:
    do_something1
    do_something2
next_something

（2）if - else

if expression:
    do_something1
else:
    do_something2

（3）if - elif - else

if expression1:
    do_something1
elif expression2:
    do_something2
else:
    do_something3

需要注意的是，if后面的条件表达式，没有()，使用：作为结尾

10、空语句pass

a = int(input("请输入一个整数:))
if a != 1:
    pass
else:
    print("hello")

其中pass表示空语句，并不会对程序的执行有任何的影响，只是占个位置，保持Python语法格式符合要求

11、循环语句

while循环

while 条件:
    循环体

例子：打印1 - 10 的整数

num = 1
while num <= 10
    print(num)
    num += 1

for循环

例子：打印1 - 10 的整数

for i in range(1, 11):
    print(i)

例子：打印2 、4、6、8、10

for i int range(2, 12, 2):
    print(i)

通过range的第三个参数， 可以指定迭代时候的步长，也就是让循环变量加几，range的步长也可以设置为负数

continue表示结束这次循环，进入下次循环

for i int range(1, 6):
    if i == 3:
        continue
    print(f"这是第{i}个数")

break

例子：输入若干个数字，求平均值，使用分号作为结尾

sum = 0
count = 0
while True
    num = input("请输入数字:")
    if num == ';'
        break
    num = float(num)
    sum += num
    count += 1
print(sum / count)

12、定义函数

def calSum(beg, end):
    sum = 0
    for i in range(beg, end + 1):
        sum += i
    print(sum)
    return sum

# 调用函数
sum(1, 100)
sum(300, 400)
sum(1, 1000)

一个函数是可以一次返回多个返回值的,使用逗号来分割多个返回值

def getPoint():
    x = 10
    y = 20
    return x, y

a, b = getPoint()

如果只想要期中的部分返回值，可以使用_来忽略不想要的返回值

def getPoint():
    x = 10
    y = 20
    return x, y

_, b = getPoint()

如果是想在函数内部，修改全局变量的值，需要使用global关键词声明

x = 20

def test():
    global x;
    x = 10
    print(f'函数内部 x = {x}')

test()
print(f'函数外部 x = {x}')

13、函数递归

代码实例：递归计算5!

def factor(n):
    if n == 1:
        return 1
    return  n * factor(n - 1)

14、参数默认值

Python中的函数，可以制定默认值
带有默认值的参数，可以在调用的时候不传参

代码实例：计算两个数字的和

def add(x, y, debug = False):
    if debug:
        print(f'调试信息: x = {x}, y = {y}')
    return x + y
print(add(10, 20))
print(add(10, 20, True))

需要注意的是：带有默认值的参数需要放到没有默认值参数的后面

15、关键字参数

在调用函数的时候，需要给函数制定实参，一般默认情况是按照形参的顺序，来依次传递实参的

但是我们也可以通过关键字参数，来调整这里的传参顺序，显示指定当前实参传递给哪个形参

def test(x, y):
    print(f'x = {x}')
    print(f'y = {y}')

test(x=10, y=20)
test(y=100, x=200)

16、列表和元组

元组和列表相比，是非常相似的，只是列表中哪些元素可以修改调整，元组中放的元素是创建元组的时候就设定好的，不能修改调整

17、列表

创建列表主要有两种方式,可以直接写在[ ]当中 

alist = [ ]
alist = list()
print(type(alist))

如果需要往里面设置初始值，可以直接写在[ ]当中

alist = [1, 2, 3, 4]
print(alist)

列表中存放的元素允许是不同的类型

alist = [1, 'hello', True]
print(alist)

使用len函数介意获取到列表的元素个数

alist = [1, 2, 3, 4]
print(len(alist))

访问列表中的东东也可以使用负数的下标,表示访问alist[len(alist) - 1]的元素

alist = [1, 2, 3, 4]
print(alist[3])
print(alist[-1])

切片操作                

        使用[ : ]的方式进行切片操作

alist = [1, 2, 3, 4]
print(alist[1:3])

上面的代码表示从1下标开始一直到2下标

alist = [1, 2, 3, 4]
print(alist[1:])        # 省略后边界, 表示获取到列表末尾
print(alist[:-1])       # 省略前边界, 表示从列表开头获取
print(alist[:])         # 省略两个边界, 表示获取到整个列表.

切片操作还可以指定步长，也就是每访问一个元素后，下标自増几步

alist = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(alist[::1])
print(alist[::2])
print(alist[::3])
print(alist[::5])

切片操作指定的步长也可以是负数，此时是从后面往前面进行取元素，表示每访问一个元素之后，下标自减几步

alist = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(alist[::-1])
print(alist[::-2])
print(alist[::-3])
print(alist[::-5])

如果切片中填写的数字越界了，不会有负面效果，只会尽可能吧满足条件的元素过去到

遍历列表元素

最简单的方法就是使用for循环

alist = [1, 2, 3, 4]

for elem in alist:
    print(elem)

也可以使用for按照范围生成下标，按下标访问

alist = [1, 2, 3, 4]

for i in range(0, len(alist)):
    print(alist[i])

还可以使用while循环，手动控制下标的变化

alist = [1, 2, 3, 4]

i = 0
while i < len(alist)
    print(alist[i])
    i += 1

新增元素

        使用append方法，向列表末尾插入一个元素

alist = [1, 2, 3, 4]
alist.append('hello')
print(alist)

        使用insert方法，向任意位置插入一个元素，insert第一个参数表示要插入的下标

alist = [1, 2, 3, 4]
alist.insert(1, 'hello')
print(alist)

查找元素

        使用in操作符，判定元素是否在列表中存在，返回值是布尔类型

alist = [1, 2, 3, 4]
print(2 in alist)
print(10 in alist)

        使用index方法，查找元素在列表中的下标，返回值是一个整数，如果元素不存在，则会抛出异常

alist = [1, 2, 3, 4]
print(alist.index(2))
print(alist.index(10))

删除元素

        使用pop方法删除最末端元素

alist = [1, 2, 3, 4]
alist.pop()
print(alist)

        pop也能按照下标来删除元素

alist = [1, 2, 3, 4]
alist.pop(2)
print(alist)

        使用remove方法，按照值删除元素

alist = [1, 2, 3, 4]
alist.remove(2)
print(alist)

        使用+能够将两个列表拼接在一起

alist = [1, 2, 3, 4]
blist = [5, 6, 7]
print(alist + blist)

        使用extend方法，相当于吧一个列表拼接到另一个列表的后面

alist = [1, 2, 3, 4]
blist = [5, 6, 7]
alist.extend(blist)
print(alist)
print(blist)

18、元组

元组使用()来表示

atuple = ( )
atuple = tuple()

元组不能修改里面的元素，列表则可以修改里面的元素

19、字典

创建一个空的字典，使用{ }表示字典

a = { }
b = dict()

print(type(a))
print(type(b))

键值对之间使用,分割，键和值之间使用:分割（冒号后面最好加一个空格）

student = {'id': 1, 'name': 'zhangsan'}
print(student)

也可以这样写

student = {
    'id': 1,
    'name': 'zhangsan'
}

最后一个键值对后面可以有逗号也可以不写

 19、查找key

使用in可以判定key是否在字典中存在，返回布尔值

student = {
    'id': 1,
    'name': 'zhangsan'
}

print('id' in student)
print('score' in student)

使用[]通过类似于取下标的方式，获取到元素的值，只不过此处的‘下标’是key

student = {
    'id': 1,
    'name': 'zhangsan'
}

print(student['id'])
print(student['name'])

如果key在字典中并不存在，则会抛出异常

使用[ ]可以根据key来新增/修改value

如果key不存在，对去下表操作赋值，即为新增键值对

student = {
    'id': 1,
    'name': 'zhangsan',
}
student['score'] = 90
print(student)

如果 key 已经存在 , 对取下标操作赋值 , 即为修改键值对的值 .

student = {
    'id': 1,
    'name': 'zhangsan',
    'score': 80
}
student['score'] = 90
print(student)

使用pop方法删除对应的键值对

student = {
    'id': 1,
    'name': 'zhangsan',
    'score': 80
}
student.pop('score')
print(student)

遍历字典元素

直接使用for循环能够获取到字典中的所有key

student = {
    'id': 1,
    'name': 'zhangsan',
    'score': 80
}
for key in student:
    print(key, student[key])

使用keys方法能够获取到字典中的所有的key

student = {
    'id': 1,
    'name': 'zhangsan',
    'score': 80
}
print(student.keys())

使用values方法能够找到字典中的所有的value

student = {
    'id': 1,
    'name': 'zhangsan',
    'score': 80
}
print(student.values())

使用items方法可以获取到字典中的所有的键值对

student = {
    'id': 1,
    'name': 'zhangsan',
    'score': 80
}
print(student.items())

需要注意的是，字典本质是哈希表，哈希表的key要求是'可哈希的'，也就是说可以计算出一个哈希值

其中：

        列表和字典无法计算哈希值

print(hash([1, 2, 3]))
print(hash({'id': 1}))

20、文件

文件路径

一个机器上，会存在很多的文件，为了让这些文件更方便的被组织，往往会使用很多的“文件夹”(也叫做目录)来整理文件
实际一个文件往往是放在一系列的目录结构当中的
为了方便确定一个文件所在的位置，使用文件路径来进行描述

 打开文件

使用内建函数open打开一个文件

f = open('d:/test.txt', 'r')

第一个参数是一个字符串，表示要打开的文件路径

第二个参数是一个字符串，表示打开方式，其中r表示按照读的方式打开，w按照写方式打开，a表示追加写方式打开

如果打开文件成功，返回一个文件对象，后续的读写文件操作都是围绕这个文件对象展开

如果打开文件失败，则会抛出异常

关闭文件

使用close方法关闭已经打开的文件

f.close()

需要注意的是，一个程序能同时打开的文件个数，是存在上限的

flist = []
count = 0
while True:
    f = open('d:/test.txt', 'r')
    flist.append(f)
    count += 1
    print(f'count = {count}')

写文件

写文件，要用写方式打开，open第二个参数设为'w'

使用write方法写入文件

f = open('d:/test.txt', 'w')
f.write('hello')
f.close()

若使用'r'方式打开文件，则写入时会抛出异常

需要注意的是：使用'w'方式一旦打开文件成功，则会清空文件原有的数据

我们如果需要追加写，则应该使用'a'这种打开方式

读文件

读文件需要使用'r'的方式打开文件

使用read方法完成读操作，参数表示，读取几个字符

f = open('d:/test.txt', 'r')
result = f.read(2)
print(result)
f.close()

如果是多行文本，可以使用for来循环读取

f = open('d:/test.txt', 'r')
for line in f:
    print(f'line = {line}')
f.close()

使用readlines直接把文件内容读取出来，返回一个列表，每个元素为一行

f = open('d:/test.txt', 'r')
lines = f.readlines()
print(lines)
f.close()

需要注意的是，读取汉字时，编码要为ANSI即GBK编码才可以正确打印出汉字

可以给open方法加上encoding参数，显式指定为和文本相同的字符集

f = open('d:/test.txt', 'r', encoding = 'utf8')

python中提供了上下文管理器，可以帮助我们自动关闭文件

使用with打开文件，当with内部的代码执行完毕后，就会自动调用关闭方法

with open('d:/test.txt', 'r', encoding='utf8') as f:
    lines = f.readlines()
    print(lines)

21、库

使用import导入模块

例子1：

import datetime

date1 = datetime.datetime(2012, 2, 14)
date2 = datetime.datetime(2022, 7, 12)

print(date2 - date1)

例子2：

题目：

输入一个英文句子，翻转句子中单词的顺序，但单词内字符的顺序不变。为简单起见，标点符号和

普通字母一样处理。例如输入字符串 "I am a student. " ，则输出 "student. a am I"

• 使用str中的split方法进行字符串切分，指定空格为分隔符，返回结果是一个列表
• 使用列表中的reverse方法进行逆序
• 使用str的join方法进行字符串拼接，把列表中的内容进行合并

def reverseWords(s):
    tokens = s.split()
    tokens.reverse()
    return ' '.join(tokens)

print(reverseWords('I am a student.'))

例子3：

题目：

给定两个字符串 , s 和 goal 。如果在若干次旋转操作之后， s 能变成 goal ，那么返回 true 。

s 的 旋转操作 就是将 s 最左边的字符移动到最右边。

例如 , 若 s = 'abcde' ，在旋转一次之后结果就是 'bcdea' 。

• 使用len求字符串的长度。如果长度不相同，则一定不能旋转得到
• 将s和自己进行拼接，然后使用in方法来判定goal是否为s+s的子串

def rotateString(s, goal):
    return len(s) == len(goal) and goal in s + s

print(rotateString('abcde', 'cdeab'))

例子4：

题目:

给你一个字符串数组 words 和一个字符串 s ，其中 words[i] 和 s 只包含 小写英文字母 。

请你返回 words 中是字符串 s 前缀 的 字符串数目 。

一个字符串的 前缀 是出现在字符串开头的子字符串。子字符串 是一个字符串中的连续一段字符序列。

• 依次遍历words中的字符串
• 直接使用字符串的startwith方法即可判定当前字符串是否是s的前缀

def countPrefixes(words, s):
    res = 0
    for word in words:
        if s.startswith(word):
            res += 1
    return res

例子5：

文件查找工具：

• 使用os.walk即可实现目录的递归遍历
• os.walk返回一个三元组，分别是当前路径，当前路径下包含的目录名，当前路径下包含的文件名

import os

inputPath = input('请输入待搜索路径：')
pattern = input('请输入待搜索关键词：')

for dirpath, dirnames, filenames in os.walk(inputPath)
    for f in filenames:
        if pattern in f:
            print(f'{dirpath}/{f}')