Python语法常用语法点总结_自用

Ohoaaa

已于 2023-05-30 17:12:54 修改

阅读量87

点赞数

文章标签： python 开发语言

于 2023-05-30 17:04:03 首次发布

本文链接：https://blog.csdn.net/Ohoaaa/article/details/130930935

版权

Python语法常用语法点总结_自用

Python基本语法知识总结

Python基本语法知识总结

基于pycharm+anaconda(3.9)环境

基本数据类型

基本数据类型有：bool，int，float，str，list，tuple，dict，set。其中为list，dict，set为可变元素，即其在内存中保存后可以在原地址处进行修改，而不是开辟一片新的地址空间。

基本的print操作；

print(123)
print(4*2)
print('hello world '*3)
print(3.4-2.1) # 输出结果并不精确，需引入科学计算的包才可实现 
# 参考网址：https://zhuanlan.zhihu.com/p/420479051

输出结果依次为：

123
8
hello world hello world hello world 
1.2999999999999998

字符串相关方法。方法较多，比较重要。
注意：str为不可变元素，在内存中存的值是无法被直接改变的，只能新存一个地方，对其进行的一系列操作对源数据是没有修改的。只有字典、集合、列表是可变的，被修改时直接修改源数据。(下同)

strs = 'hello world'
#  (1) 大小写转换
print(strs.upper())
print(strs.lower())
print(strs.title())  # 首字母大写
print(strs.swapcase()) # 大小写互转

输出结果依次为：

HELLO WORLD
hello world
Hello World
HELLO WORLD

# (2) 字符串拆分
print(strs.split(' '))  # 根据空格来拆分 拆分结果为列表

输出结果为：

['hello', 'world']

# (3) 字符串增删查 改的话重新需要赋值
print(strs+' ni hao')
# 字符串格式化 %s format 相似的功能
print('nihao {}'.format('小明'))
# 字符串根据切片取一部分
print(strs[:5])  # 取到位置是end-1
# 字符串查找
print(strs.find('o'))  # 输出为该该字母下标
print(strs[:strs.find('o')+1])
print(strs.index('o'))  # index和find功能相同

输出结果为：

hello world ni hao
nihao 小明
hello
4
hello
4

整型数据转化为字符串？

print(str(123), type(str(123)))
print(int('123'))

列表相关方法。

# (1) 列表生成式
lists = [x for x in range(1, 101)]  # range start,end-1
print(lists)
lists1 = [x for x in range(1, 101) if x % 2 == 0]
lists2 = [x for x in range(1, 101) if x % 2 == 1]
print(lists1)
print(lists2)
lists3 = [x if x % 2 == 1 else -x for x in range(1, 101)]  # 奇数为+ 偶数为-
print(lists3)
#  range(1, 101，1)  步长为1

输出结果为：

lists: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100]
lists1: [2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98, 100]
lists2: [1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33, 35, 37, 39, 41, 43, 45, 47, 49, 51, 53, 55, 57, 59, 61, 63, 65, 67, 69, 71, 73, 75, 77, 79, 81, 83, 85, 87, 89, 91, 93, 95, 97, 99]
lists3: [1, -2, 3, -4, 5, -6, 7, -8, 9, -10, 11, -12, 13, -14, 15, -16, 17, -18, 19, -20, 21, -22, 23, -24, 25, -26, 27, -28, 29, -30, 31, -32, 33, -34, 35, -36, 37, -38, 39, -40, 41, -42, 43, -44, 45, -46, 47, -48, 49, -50, 51, -52, 53, -54, 55, -56, 57, -58, 59, -60, 61, -62, 63, -64, 65, -66, 67, -68, 69, -70, 71, -72, 73, -74, 75, -76, 77, -78, 79, -80, 81, -82, 83, -84, 85, -86, 87, -88, 89, -90, 91, -92, 93, -94, 95, -96, 97, -98, 99, -100]

# (2) 逆序输出
lists = [1,2,3,4,5]
print(lists[::-1])

输出结果为：

[5, 4, 3, 2, 1]

# (3) 字符串的拆分与合并
liststr = strs.split(' ')
print(' '.join(liststr))

输出结果为：

hello world

# (4) 列表基本运算操作
# 1. 增
lists = [1, 2, 3, 4]
print(lists)
lists.append(5)
print(lists)
lists.extend([5, 6])
print(lists)
lists.insert(1, 1)  # 指定位置插入 前两个默认插入在尾部
print(lists)
lists = lists + [1, 2, 3]
print(lists)

输出结果为：

[1, 2, 3, 4]
[1, 2, 3, 4, 5]
[1, 2, 3, 4, 5, 5, 6]
[1, 1, 2, 3, 4, 5, 5, 6]
[1, 1, 2, 3, 4, 5, 5, 6, 1, 2, 3]

# 2. 删
print(lists.pop())  # 弹出最后一个数
print(lists)
print(lists.pop(0))  # 指定下标弹出
print(lists)
lists.remove(lists[0])  # 输入参数为需要删除元素的值

输出结果为：

3
[1, 1, 2, 3, 4, 5, 5, 6, 1, 2]
1
[1, 2, 3, 4, 5, 5, 6, 1, 2]
[2, 3, 4, 5, 5, 6, 1, 2]

# 3. 改
print(lists[1:3])
lists[1:3] = 'world'  # 实际上会把各个字母拆出来
print(lists)
# 输出：['hello', 'w', 'o', 'r', 'l', 'd', 4]
# print(lists[88])   # 会报错，越界
print(lists[88:])  # 这个不会报错

# 4. 查(遍历)
for i in lists:
    print(i)
for i in range(len(lists)):
    print(lists[i])

特别的，map方法，可以免遍历完成对列表的中各个元素的简单运算操作。

lists = [1,2,3]
data = list(map(lambda x:x+2, lists))
# 输出为[3, 4, 5]

字典相关方法。字典由键值对，键必须为不可变元素且不可重复，但值可以重复。可以类比函数。

# (1) 定义
dict = {'hello': 'world', (1,2,3): 666}  # (1,2,3)元组
print(dict)
# (2) 列表相关操作
# 1. 增
dict['nihao'] = '王小明'  # 自动创建键值对
print(dict)
dict.update({'nihao':'王明'})  # 字典合并方法
print(dict)

输出结果为：

{'hello': 'world', (1, 2, 3): 666}
{'hello': 'world', (1, 2, 3): 666, 'nihao': '王小明'}
{'hello': 'world', (1, 2, 3): 666, 'nihao': '王明'}

# 2. 删  
print(dict.pop('hello'))  # 输出的是键对应的值
print(dict)
del dict[(1,2,3)]
print(dict)

# 3. 改
# 增加时如果用的是之前的键 就直接改了
dict['hello'] = 234
dict['hello'] = 123

# 4. 查(遍历)
# 增加时如果用的是之前的键 就直接改了
for i in dict:
    print(i)   # 遍历的是键

for i in dict:
    print(i, dict[i])

for a, b in dict.items():
    print(a, b)  # 把字典键值对变成元组与列表的混合

dict.keys()是python特有的数据类型，可以当列表用但列表有的功能它不支持，直接强行用list()转换为列表即可

print(list(dict.keys()))
print(dict.values())

集合相关操作。集合主要用于去重操作，就像数学中对集合的定义一样，无序且无重复元素。与字典键的要求相同，集合中的元素必须为不可变元素，不能接受可变元素(list、dict、set)。

s = {'q', 'hello', 'q'}
print(s)
# 输出为：{'hello', 'q'}
# (1) 增加集合元素
s.add('qqq')  # 集合是无序的 不可以通过下标取值 集合与字典的性质是相似的
print(s)
# 输出为：{'hello', 'qqq', 'q'}
# (2) 集合的特殊运算 交并补差
ss = {'q', '太阳', '大地瓜'}
print(ss-s)  # 差集
print(ss | s)  # 并集
print(ss & s)  # 交集
print(ss ^ s)  # 补集 各自不一样的写在一起
# 输出为：
# {'大地瓜', '太阳'}
# {'大地瓜', 'q', 'qqq', '太阳', 'hello'}
# {'q'}
# {'大地瓜', 'hello', 'qqq', '太阳'}
# (3) 删除集合中的元素 只能随机删除 不常用
ss.pop()

元组相关操作。元组可以理解为特殊的列表，是不可变元素，没有增删改操作，只有查。在容器里数据不希望被修改的时候，一般选择用元组，比如共享的时候。

t = (1, 2, 3, 4)
t1 = (2) # t1不是元组
print(type(t1))  
# 输出：<class 'int'> 因为python计算有优先级
t1 = (2,) 
print(type(t1))  
# 输出 <class 'tuple'> 只有一个元素的时候要加，
# 可以取下标 可以遍历 不可修改

函数相关。

(1) 函数定义
(2) 函数调用

def hello():
    return '123', 12
# 可以以元组形式返回多个值
print(hello())
# 函数定义几个参数就传几个值
def hello(a, b, c, d):
    return '123', 12
print(hello(1,2,3,4))
# 函数定义几个参数就穿几个值
# 以上2个输出都是一样的 ('123', 12)

def hello(*args):
    return args
print(hello(1,2,3,4.5))
# 输出(1, 2, 3, 4.5)

# 可以传任意多键值对 不受限制
def hello1(**args):  
    return args
print(hello1(name = '王铁柱', age = 18))

def hello(name = '王小明'):
    print(name)
hello('qqq')
# 输出为 qqq  实参优先级高于形参

def hello(qaq, name = '王小明'):
    print(name)
hello(name = 'qqq',qaq = 111)

变量起名小贴士：驼峰命名法 AndBandCend 或者下划线分割。abcd这种起名方式常用在代码混淆里。

关于生成器、迭代器、可迭代对象。

从前到后涉及范围依次扩大。
凡是可以被for循环遍历的就是可迭代对象(范围最大) 可迭代即可遍历。迭代器是能被next函数调用并不断返回下一个值，生成器是特殊的迭代器。

g = iter([1, 2, 3, 4])  # g是一个简单的迭代器
print(next(g))
print(next(g))
print(next(g))
print(next(g))

输出为：
1
2
3
4

print(hello())
# <generator object hello at 0x00000173FD6EB350> 返回生成器对象
print(next(hello()))
print(next(hello()))
print(next(hello()))
print(next(hello()))
# 后面这几个出来的都是1
print('加具体变量后：')
data = hello()
print(next(data))
print(next(data))
print(next(data))
# 也可以
print('用for循环直接遍历也可以：')
for i in hello():
    print(i)

输出为：
<generator object hello at 0x000001E892E5DB30>
1
1
1
1
加具体变量后：
1
2
3
用for循环直接遍历也可以：
1
2
3

生成器是生成东西的，节省内存空间，不调用就不产出，避免资源浪费。

data = (x for x in range(10))  # 与hello()定义的东西道理是一样的
print(data)
# 输出为：<generator object <genexpr> at 0x000001DF9BCF6660>
print(list(data))
# 输出为：[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]