Python快速入门(一)基本语法特性

最新推荐文章于 2024-08-15 01:55:01 发布

复读机3827

最新推荐文章于 2024-08-15 01:55:01 发布

阅读量98

点赞数

分类专栏： Python 文章标签： python 开发语言 pycharm

本文链接：https://blog.csdn.net/qq_61603262/article/details/128718929

版权

Python 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

注：本文主要面向有其他语言基础的同学，旨在记录Python基础语法中和其他语言的区别，方便快速上手，对0基础者可能不太友好

1.数值运算

1.赋值

系列解包赋值

x,y=y,x #交换数值
a,b,c=1,2,3

链式赋值

a=b=12

(python不支持常量)

2.增强运算符

Python支持+=、-=等增强运算符，但不支持++、–

3.时间获取与格式化

获取时间：

print(time.time())#浮点数时间戳
print(time.localtime(time.time()))#时间元组
datetime.datetime.now()#直接拿到全部内容，格式为年-月-日 时:分:秒.毫秒，具体属性获取方式同下文
date01 = datetime.date.today()#年-月-日
	print("年份",date01.year)
	print("月份",date01.month)
	print("日期",date01.day)
time01 = datetime.time()
	print("时",time01.hour)
	print("分",time01.minute)
	print("秒",time01.second)
	print("微秒",time01.microsecond)

格式化为标准格式(获取本地时间时，格式化可以不输入参数)：

time.asctime(time.localtime())  # 参数为时间元组
time.ctime(time.time())  # 参数为浮点数时间戳

格式化为自定义格式：

print(time.strftime("%Y-%m-%d %H:%M:%S",time.localtime()))
print(time.strftime("%a %b %d %H:%M:%S %Y",time.localtime()))

输出：

2023-01-16 17:45:01
Mon Jan 16 17:45:01 2023

2.字符串操作

1.字符和Unicode转换

ord('A')#获取A的ASCII码
chr(114)#获取114对应的字符

2.replace()实现字符串内容替换

Python的字符串是不可更改的，replace()实际上是输出了一个新的字符串

实例

s='114514'
s.replace('1','0')
print(s)
s=s.replace('1','0')
print(s)

输出

114514
004504

3.切片

实例

s='012345'
print(s[:2])#向前切片
print(s[2:])#向后切片
print(s[1:3])
print(s[:])#获取完整字符串
print(s[1:5:2])#按步长获取
print("---------------------------")
print(s[-1])#从后往前计算偏移量
print(s[-2:])#向后切片
print(s[:-2])#向前切片
print("当首末偏移量不满足大小关系时，输出为"+str(s[-2:-5]))#啥也不输出
print(s[-5:-2])#倒序切片
print(s[::-1])#整个字符串倒序

输出

01
2345
12
012345
13
---------------------------
5
45
0123
当首末偏移量不满足大小关系时，输出：
123
543210

4.split()与join()

split()将字符串按指定分隔符（不指定分隔符则默认使用空格、换行符）分割成列表

join()将字符作为分隔符插入到列表中并将之转换为字符串

实例

s="1a2a3a4"
s=s.split('a')
print(s)
s='b'.join(s)
print(s)

输出

['1', '2', '3', '4']
1b2b3b4

join()的效率远高于用+=衔接字符串，测试如下

import time

s = ''
i = 0
t0=time.time()
for i in range(11451):
    s += ' ***这是一次循环*** \n'
print(time.time()-t0)

s = ''
i = 0
t0=time.time()
for i in range(11451):
    ' ***这是一次循环*** \n'.join(s)
print(time.time()-t0)

输出

0.3703339099884033
0.003916501998901367

显然，此时join()方法比+=衔接快了两个数量级。

5.查找字符

in/not in用于判断字符串包含关系，输出布尔类型

print('11'in'114')
print('1'not in'444')

startswith()/endswith():用于判断字符串开头结尾

find()/rfind():找到指定字符串第一次/最后一次出现的位置索引(可加入索引参数来在指定范围查找)

isalnum():判断字符串是否仅包含字母数字

count():输出某字符在字符串中出现次数

6.其他字符串编辑函数

strip()/rstrip()/lstrip():用去去除字符串首尾/首/尾指定字符串

capitalize():产生新的字符串,首字母大写
title():产生新的字符串,每个单词都首字母大写
upper():产生新的字符串,所有字符全转成大写
lower():产生新的字符串,所有字符全转成小写

a.swapcase():产生新的字符串,所有字母大小写转换

center()、ljust()、rjust()实现排版（居中，左对齐，右对齐，可加作占位符的另一参数）

isalnum() 是否为字母或数字

isalpha() 检测字符串是否只由字母组成(含汉字)。

isdigit() 检测字符串是否只由数字组成。

isspace() 检测是否为空白符

isupper() 是否为大写字母

islower() 是否为小写字母

7.str.format()实现格式化

和Java用法很相像，直接上实例

s='''------测试字符串------
姓名：{0}
性别：{1}
年龄：{2}
职业：{3}
'''
print(s)
print(s.format('李田所','男','24','学生'))

输出

------测试字符串------
姓名：{0}
性别：{1}
年龄：{2}
职业：{3}

------测试字符串------
姓名：李田所
性别：男
年龄：24
职业：学生

上面是通过索引实现的方法。此外，Python还支持用参数名实现格式化：

s = '''------测试字符串------
姓名：{name}
性别：{性别}
年龄：{年龄}
职业：{职业}
'''
print(s)
print(s.format(name='李田所', 性别='男', 年龄='24', 职业='学生'))

效果同上。

填充与对齐

填充常跟对齐一起使用
^、<、>分别是居中、左对齐、右对齐，后面带宽度
:号后面带填充的字符，只能是一个字符，不指定的话默认是用空格填充

实例

s = '''------测试字符串------
姓名：{0:*>8}
性别：{1:*<8}
年龄：{2:-^8}
职业：{3}
'''
print(s)
print(s.format('李田所', '男', '24', '学生'))

输出

------测试字符串------
姓名：{0:*>8}
性别：{1:*<8}
年龄：{2:-^8}
职业：{3}

------测试字符串------
姓名：*****李田所
性别：男*******
年龄：---24---
职业：学生

数字格式化

数字	格式	输出	描述
3.1415926	{:.2f}	3.14	保留小数点后两位
3.1415926	{:+.2f}	3.14	带符号保留小数点后两位
2.71828	{:.0f}	3	不带小数
5	{:0>2d}	05	数字补零 (填充左边, 宽度为2)
5	{:x<4d}	5xxx	数字补x (填充右边, 宽度为4)
10	{:x<4d}	10xx	数字补x (填充右边, 宽度为4)
1000000	{:,}	1,000,000	以逗号分隔的数字格式
0.25	{:.2%}	25.00%	百分比格式
1000000000	{:.2e}	1.00E+09	指数记法
13	{:10d}	13	右对齐 (默认, 宽度为10)
13	{:<10d}	13	左对齐 (宽度为10)
13	{:^10d}	13	中间对齐 (宽度为10)

8.利用io.StringIO()实现可变字符串

实例

import io

s = '123456789'
sio=io.StringIO(s)
sio.write('g')
sio.seek(5)#指针移动到指定索引处
sio.write('g')#写入（修改）操作
print(sio.getvalue())

输出

g2345g789

3.集合

*这里的集合指的是collections

1.列表List：有序的、可存放多种类型数据的集合

方法	要点	描述
list.append(x)	增加元素	将元素x增加到列表list尾部
list.extend(aList)	增加元素	将列表alist所有元素加到列表list尾部
list.insert(index,x)	增加元素	在列表list指定位置index处插入元素x
list.remove(x)	删除元素	在列表list中删除首次出现的指定元素x
list.pop([index])	删除元素	删除并返回列表list指定为止index处的元素，默认是最后一个元素
list.clear()	删除所有元素	删除列表所有元素，并不是删除列表对象
list.index(x)	访问元素	返回第一个x的索引位置，若不存在x元素抛出异常
list.count(x)	计数	返回指定元素x在列表list中出现的次数
len(list)	列表长度	返回列表中包含元素的个数
list.reverse()	翻转列表	所有元素原地翻转
list.sort()	排序	所有元素原地排序
list.copy()	浅拷贝	返回列表对象的浅拷贝
sorted()		返回升序排序后的副本，不改变原列表
reversed()		返回降序排序的迭代器，list(list.reversed())获取降序的列表

2.元组tuple

元组属于不可变序列，不能修改元组中的元素。元组支持如下操作：

索引访问
切片操作
连接操作
成员关系操作
比较运算操作
计数：元组长度len()、最大值max()、最小值min()、求和sum()等。

创建

a = (10,20,30)    
b = 10,20,30
c = tuple()		#创建一个空元组对象
d = tuple("abc")
dd = tuple(range(3))
ddd = tuple([2,3,4])

其他非修改操作基本同list

3.字典

键值对的无序可变序列。这玩意很像hashmap，但是可以直接定义，不需要先建个空集合然后往里一个一个塞键值对。

创建

a = {'name':'gaoqi','age':18,'job':'programmer'}
b = dict(name='gaoqi',age=18,job='programmer')
a = dict([("name","gaoqi"),("age",18)])
c = {}   #空的字典对象
d = dict()   #空的字典对象

或是通过zip()

k = ('name', 'age', 'job')
v = ['李田所', 24, 'student']
d = dict(zip(k, v))
print(d)

显然，key和value都可以用list或tuple传入。k-v须要一一对应，但value支持空值。

创建只有key，value全部为空的字典：

a = dict.fromkeys(['name','age','job'])

读取

1.通过字典 [键] 获得“值”。若键不存在，则抛出异常。

2.通过get()方法获得“值”。推荐使用。优点是：指定键不存在，返回None；也可以设定指定键不存在时默认返回的对象。推荐使用get()获取“值对象”。

3.列出所有的键：通过keys()方法

4.列出所有的值：通过 values()方法

增/改

1.a[‘newKey’]=‘newValue’

2.字典.update(新字典)：将新字典加入旧字典，键值重复则直接覆盖。

删除

1.del(dict[key])方法

2.dict.clear()：删除所有键值对

3.dict.pop()删除指定键值对，并返回对应的“值对象”

4.dict.popitem()随机弹出键值对

序列解包

直接上实例

dict = {'name': '张三', 'age': 18, 'job': 'theft'}
print(dict)
#输出：{'name': '张三', 'age': 18, 'job': 'theft'}
姓名,年龄,职业=dict
print(姓名,职业)
#输出：name job

姓名,年龄,职业=dict.items()
print(姓名,职业)
#输出：('name', '张三') ('job', 'theft')

姓名,年龄,职业=dict.keys()
print(姓名,职业)
#输出：name job

姓名,年龄,职业=dict.values()
print(姓名,职业)
#输出：张三 theft

输出

{'name': '张三', 'age': 18, 'job': 'theft'}
name job
-------------------------
('name', '张三') ('job', 'theft')
-------------------------
name job
-------------------------
张三 theft

4.集合（Set）

集合无序可变，元素不能重复。实际上，集合底层是字典实现，集合的所有元素都是字典中的“键对象”，因此是不能重复的且唯一的。

创建

a={1,2,3}#直接新建
a=set([1,2,2,3,3,3])
a=set((1,,2,3,3,3))

添加元素

a.add('x')

删除

remove()删除指定元素，clear()清空整个集合

集合间运算

a|b 或 a.union(b) #并集

a&b 或 a.intersection(b) #交集

a-b 或 a.difference(b) #差集

4.控制语句

1.三元运算符

Python提供了三元运算符，用来在某些简单双分支赋值情况。三元条件运算符语法格式如下：

条件为真时的值 if (条件表达式) else 条件为假时的值，实例：

a=int(input("plz input the number\n"))
print("a>0") if a>0 else print("a<=0")

2.for循环

一句话概括：这一循环的用法更类似于Java中的foreach

Python 的 for 语句与 C 或 Pascal 中的不同。Python 的 for 语句不迭代算术递增数值（如 Pascal），或是给予用户定义迭代步骤和暂停条件的能力（如 C/java），而是迭代列表或字符串等任意序列，元素的迭代顺序与在序列中出现的顺序一致。

语法：

for iterating_var in sequence:
   statements(s)

实例：

"""打印质数表"""
m = int(1)
for m in range(3):
    maxNumber = int(input("请输入数值范围\n"))
    i = int(1)
    j = int(2)
    k = int(0)
    for i in range(2, maxNumber):
        for j in range(2, maxNumber):
            if (i == j):
                print(str(i) + "是质数")
                break
            if (i % j == 0):
                # print(str(i)+"不是质数")
                break

这玩意甚至还能用于创建集合

a = [x ** 2 for x in range(1, 20) if x % 5 == 0]
print(a)
#输出：[25, 100, 225]
a =  [words  for  words  in "abcdefg"]
print(a)
#输出：['a', 'b', 'c', 'd', 'e', 'f', 'g']
a =  "hkjhgjkihjhwy809qrya34e982    hjrksdwhfkay487hjlkhdkjcfhkjasd kwjehkjdf edjbfkjbd "
dict={ c:a.count(c) for c in a}
print(dict)
#输出{'h': 10, 'k': 10, 'j': 11, 'g': 1, 'i': 1, 'w': 3, 'y': 3, '8': 3, '0': 1, '9': 2, 'q': 1, 'r': 2, 'a': 3, '3': 1, '4': 2, 'e': 3, '2': 1, ' ': 7, 's': 2, 'd': 6, 'f': 4, '7': 1, 'l': 1, 'c': 1, 'b': 2}
a =  "11111 "
dict={ c:a.find(c) for c in a}
print(dict)
#{'1': 0, ' ': 5}

需要注意的是，元组不支持这种创建方式。用类似语法创建元组时，得到的是一个迭代器。

3.match语句

Python3.10之后终于有了swtich，但没完全有，因为他叫match.

实例

a=int(input("plz input the number\n"))
match a:
    case 1:print("a=1")
    case 2:print("a=2")
    case default:print("others")

这里的default仅仅只是一个变量名而已，并非规定写法，也可以使用其他变量名，例如x等。其作用就是在变量不符合任意一个分支条件时，将变量值赋值给该变量。

如果我们想用集合呢？match也可以满足

a = (-1000, 0)
match a:
    case (1,100 ):
        print("case=1")
    case (-1000, 0):
        print("case=2")
    case default:
        print("others")
 #输出 case=2

甚至可以加入if语句

a = (-1000, 0)
match a:
    case (1,100 ):
        print("case=1")
    case (-1000, 0) if  False:
        print("case=2")
    case default:
        print("others")
 #输出 others

z input the number\n"))
match a:
case 1:print(“a=1”)
case 2:print(“a=2”)
case default:print(“others”)


这里的default仅仅只是一个变量名而已，并非规定写法，也可以使用其他变量名，例如x等。其作用就是在变量不符合任意一个分支条件时，将变量值赋值给该变量。

如果我们想用集合呢？match也可以满足

```python
a = (-1000, 0)
match a:
    case (1,100 ):
        print("case=1")
    case (-1000, 0):
        print("case=2")
    case default:
        print("others")
 #输出 case=2

甚至可以加入if语句

a = (-1000, 0)
match a:
    case (1,100 ):
        print("case=1")
    case (-1000, 0) if  False:
        print("case=2")
    case default:
        print("others")
 #输出 others