Python基础语法_input.split() 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)

1. 使用 pop 删除列表中的最末尾的元素.
2. 使用 pop 还能删除任意位置的元素. pop 的参数可以传一个下标过去.
3. 使用 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)

1. 使用 + 针对两个列表进行拼接.
2. 使用 extend 来进行拼接.a.extend(b)不涉及拷贝
3. 使用 += 来进行拼接,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])

1. 使用 in 来判定某个 key 是否在字典中存在.in 只是判定 key 是否存在, 和 value 无关!
2. not in 来判定 key 在字典中不存在
3. 使用 [ ] 来根据 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

1. 输入要查找的路径, 输入要搜索的文件名(一部分)

2. 自动的在指定的路径中进行查找~

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 返回一个三元组, 分别是 当前路径 , 当前路径下包含的目录名 (多个), 当前路径下包含的文件名 (多个)