Python重要语法回顾-1-基础、字符串、索引、List、dict、集合、赋值机制

0、简介

本文内容为 Jupyter Notebook 直接下载为md 生成

从 Jupyter Notebook 角度看

a=3
1

print("hello")
1

hello

print('world')
1

world

print(a)
1

3

import os
print(os.path.abspath('.'))
1
2

C:\Users\hanzhuan

• 查看当前目录

import os
print(os.path.abspath('.'))
1
2

E:\data\ProjectData\JupyteNotebook\01-hello

Python之歌

import this
1

The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

1、Python基础

1.1 Python数值运算

1+1
2+2
1
2

4

print(1+1)
2+2
1
2

2
4

10/3
1

3.3333333333333335

10%3
1

1

2**3
1

8

a=3
1

a
1

3

type(varName) 打印类型

type (a)
1

int

f = 1.5
1

type(f)
1

float

类型转换(几种常见类型)

• int
• float
• str
• bool

int(f)
1

1

b = int(f)
1

type(b)
1

int

c=float(b)
1

type(c)
1

float

a_str="123"
1

float(a_str)
1

123.0

a_str="123a"
1

float(a_str)
1

---

ValueError Traceback (most recent call last)
Input In [28], in ()
----> 1 float(a_str)

ValueError: could not convert string to float: ‘123a’

b = true
1

b
1

True

type(b)
1

bool

3>5
1

False

x=3
1<x<6
1
2

True

1.2 基本数值处理 (简单数学函数)

abs(-2.6)
1

2.6

round(2.6)
1

3

min(4,5,2,6,1)
1

1

max(4,5,2,6,1)
1

6

100000e-4
1

10.0

10e100
1

1e+101

2**10
1

1024

2、Python字符串

2.1 字符串基本使用

hza_str="hello python "
1

print(hza_str)
1

hello python

hza_str='hello '+'python '
hza_str
1
2

'hello python ’

hza_str*3
1

'hello python hello python hello python ’

hza='hello'
1

len(hza)
1

5

2.2 字符串常用操作

split切割 join合并

tang='1 2 3 4 5'
tang.split()
1
2

[‘1’, ‘2’, ‘3’, ‘4’, ‘5’]

tang='1,2,3,4,5'
tang=tang.split(',')
1
2

tang
1

[‘1’, ‘2’, ‘3’, ‘4’, ‘5’]

tang_str= ' '
tang_str.join(tang)
1
2

‘1 2 3 4 5’

字符串替换

hza='hello python'
hza.replace('python','world')
1
2

‘hello world’

hza
# 并未改变hza变量本身
1
2

‘hello python’

hza2=hza.replace('python','world')
#新赋值给变量才行
1
2

hza2
1

‘hello world’

大小写转换

hza2.upper()
1

‘HELLO WORLD’

hza2='HELLO WORLD'
hza2.lower()
1
2

‘hello world’

strip() 去掉前后空格

hza="     hello python  "
hza.strip()
1
2

‘hello python’

hza
1

’ hello python ’

hza.lstrip()
1

'hello python ’

hza.rstrip()
1

’ hello python’

str.format()

'{} {} {}'.format('han','zhu','an')
1

‘han zhu an’

'{2} {1} {0}'.format('han','zhu','an')
1

‘an zhu han’

'{han},{zhu},{an}'.format(han=10,zhu=20,an=30) 
# 参数形式传入
1
2

‘10,20,30’

han='han zhu an:'
b=123.5
c=985
result = '%s %f %d' % (han,b,c)
result
# 就是print格式化输出的那个语法
1
2
3
4
5
6

‘han zhu an: 123.500000 985’

3、Python索引

3.1 简单索引

• 从前面是0开始
• 从后面是-1开始

hza='han zhu an'
print(hza[0])
print(hza[4])
hza[8]
1
2
3
4

h
z
‘a’

hza[-1]
#从后往前 第一个
1
2

‘n’

hza[-6]
1

‘z’

hza[10]
# 索引也不能越界
1
2

---

IndexError Traceback (most recent call last)
Input In [10], in ()
----> 1 hza[10]

IndexError: string index out of range

3.2 切片

[m:n] 表示从索引m到n-1
仍然是: 左闭右开的区间

hza[0:3]
# [0,3) 还是左闭右开  =》[0,2]
1
2

‘han’

hza[4:7]
1

‘zhu’

hza
1

‘han zhu an’

hza[4:]
# 索引4(0开始)开始后面所有
1
2

‘zhu an’

hza[:7]
# 开始直到下标6 (还是不包括右)
1
2

‘han zhu’

hza[2:-1]
# 开头第2个取到倒数第1个
1
2

‘n zhu a’

hza[-2:]
# 倒数第2个开始 一直往后取
1
2

‘an’

hza
1

‘han zhu an’

hza[:-3]
# 从开始一直取到倒数第4个 
1
2

‘han zhu’

hza[:]
# 取所有
1
2

‘han zhu an’

hza[::2]
# 每隔2个取一个值  也即：0 2 4 6 8
1
2

‘hnzua’

4、Python-List 列表

4.1 创建与简单使用

• 通过[]创建一个list结构
• 里面放任何类型都可以，没有一个长度限制

hza=[]
1

type(hza)
1

list

hza=[1,2,3,4]
hza
1
2

[1, 2, 3, 4]

hza=['1','2','3','4']
hza
1
2

[‘1’, ‘2’, ‘3’, ‘4’]

hza=[1,'hza',3.5]
hza
1
2

[1, ‘hza’, 3.5]

hza=list()
print(type(hza))
# 其他建立List的方式

hza=list([1,2,3])
hza
# 其他建立List的方式

#不建议 还是怎么方便怎么来就行了
1
2
3
4
5
6
7
8
9

[1, 2, 3]

4.2 list常用操作

hza=[1,2,3]
len(hza)
# 长度
1
2
3

3

a= [123,567]
b = ['han','zhu','an']
a+b
# list 拼接
1
2
3
4

[123, 567, ‘han’, ‘zhu’, ‘an’]

a*2
# list乘整数 ： 复制
1
2

[123, 567, 123, 567]

a
1

[123, 567]

print(a[0])
print(a[1])
print(a[-1])
# 索引的使用还是一样
1
2
3
4

123
567
567

print(a[2])
# 索引也不能越界
1
2

---

IndexError Traceback (most recent call last)
Input In [16], in ()
----> 1 print(a[2])

IndexError: list index out of range

a
1

[123, 567]

a[0]=456
a
1
2

[456, 567]

a[:]=['han','zhu']
a
# 整体替换
1
2
3

[‘han’, ‘zhu’]

a=[0,1,2,3,4,5,6,7]
a[2:5]
# 和数组一样 取任意部分
1
2
3

[2, 3, 4]

del a[0]
a
# 真的删除a中某个元素  再执行一次又会把元素1删除
1
2
3

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

del a[4:]
# 删一堆 索引4开始一直往后所有元素全部删除
a
1
2
3

[1, 2, 3, 4]

a=[1,2,3,4,5,6,7,8,9]
8 in a
# 8是否在a中
# 判断元素是否在list中 in
1
2
3
4

True

10 in a
1

False

10 not in a
1

True

hza=['han','zhu','an']
'han' in hza
#元素换成字符串 一样的
1
2
3

True

5、Python-dict 字典

5.1 字典基础

• 就是java/c++ 里的Map

hza={}
type(hza)
1
2

dict

hza=dict()
type(hza)
1
2

dict

hza
1

{}

5.2 字典结构操作

key - value

hza={}
hza['first']=123
hza
# 先声明字典 再使用字典
1
2
3
4

{‘first’: 123}

hza['python']=456
hza
1
2

{‘first’: 123, ‘python’: 456}

hza['python']
1

456

hza['python']=789
hza
1
2

{‘first’: 123, ‘python’: 789}

hza={'han':123, 'zhu':456, 'an':789}
hza
1
2

{‘han’: 123, ‘zhu’: 456, ‘an’: 789}

hza[0]
# 有自己的key  不能用普通数字索引访问了
1
2

---

KeyError Traceback (most recent call last)
Input In [16], in ()
----> 1 hza[0]

KeyError: 0

value可以是复杂类型

hza_value=[1,2,3]
hza={}
hza['zhuan']=hza_value
hza['zhuan2']=3
hza['zhuan3']='4'
hza
# 字典value可以是任意类型
1
2
3
4
5
6
7

{‘zhuan’: [1, 2, 3], ‘zhuan2’: 3, ‘zhuan3’: ‘4’}

hza = {}
d1 = {'tang':123, 'yudi':456}
d2={'tang2':456, 'yudi2':789}
hza['test1']=d1
hza['test2']=d2
hza
# value可以是嵌套的字典
1
2
3
4
5
6
7

{‘test1’: {‘tang’: 123, ‘yudi’: 456}, ‘test2’: {‘tang2’: 456, ‘yudi2’: 789}}

dict 直接赋值键值对(key,value)

• get获取值

hza=dict([('han',123),('zhuan',456)])
hza
# (key,value)形式直接给字典赋值
1
2
3

{‘han’: 123, ‘zhuan’: 456}

hza['han'] += 1
hza
1
2

{‘han’: 124, ‘zhuan’: 456}

hza.get('han')
# 和javaMap一样的取也行
1
2

124

hza['an']
# 没有的key报错
1
2

---

KeyError Traceback (most recent call
last) Input In [8], in ()
----> 1 hza[‘an’] KeyError: ‘an’

hza.get('an')
# 没有的key不报错 
1
2

hza.get('an','hanzhu')
# 直接返回value 原来的字典没有加入新值
1
2

‘hanzhu’

删除元素 pop() del

hza
1

{‘han’: 124, ‘zhuan’: 456}

hza.pop('han')
# 直接当栈来用  或者说：删除元素
1
2

124

hza
1

{‘zhuan’: 456}

del hza['zhuan']
hza
# 删除元素  key为参数即可
1
2
3

{}

update更新字典

hza={'han':123, 'zhuan':456}
hza2={'han':789,'python':888}
hza.update(hza2)
# 用另一个字典hza2更新本字典hza  hza本来有的key更新value  hza原来没有的key直接加入
hza
1
2
3
4
5

{‘han’: 789, ‘zhuan’: 456, ‘python’: 888}

in 判断key是否在字典中

'han' in hza
1

True

'hello' in hza
1

False

keys()获取所有键

hza
1

{‘han’: 789, ‘zhuan’: 456, ‘python’: 888}

hza.keys()
1

dict_keys([‘han’, ‘zhuan’, ‘python’])

values()获取所有值

hza.values()
1

dict_values([789, 456, 888])

items()获取所有键值对

hza.items()
1

dict_items([(‘han’, 789), (‘zhuan’, 456), (‘python’, 888)])

# for循环直接方便地遍历字典
for key,value in hza.items():
    print(key,value)
1
2
3

han 789
zhuan 456
python 888

# 可以直接返回多个值
def max_min(*arr):
    a=max(arr)
    b=min(arr)
    return a,b
    
a,b = max_min(8,9,0,12,3)
print(a,b)
1
2
3
4
5
6
7
8

12 0

6、Python 集合

6.1 认识集合

• 元素不重复

hza=[123,123,456,456,789]
hza=set(hza)
hza
1
2
3

{123, 456, 789}

hza=set()
type(hza)
1
2

set

# list转集合
hza=set([123,123,456,456,456,789,789])
hza
1
2
3

{123, 456, 789}

# 真直接构造集合 (可以看成字典的key)
hza={123,456,789,123,456,788}
hza
1
2
3

{123, 456, 788, 789}

6.2 集合的操作

• 交 intersection &
• 并 union |
• 差

a并b

• a.union(b)
• a | b

a={1,2,3,4}
b={2,3,4,5}
1
2

a.union(b)
# a并b
1
2

{1, 2, 3, 4, 5}

a | b
1

{1, 2, 3, 4, 5}

a交b

• a.intersection(b)
• a & b

a.intersection(b)
1

{2, 3, 4}

a & b
1

{2, 3, 4}

a差b

• a.difference(b)
• a - b
• b - a

a.difference(b)
1

{1}

a-b
1

{1}

b.difference(a)
1

{5}

b-a
1

{5}

集合间关系

a={1,2,3,4,5,6}
b={2,3,4}
1
2

是否是子集

• issubset
• <=

b.issubset(a)
# b是否为a的子集
1
2

True

a.issubset(b)
# a是否为b的子集
1
2

False

b<=a
1

True

b>a
1

False

a<=a
# 自己是自己的子集
1
2

True

a<a
# 自己不是自己的真子集
1
2

False

add 给集合添加元素

a={1,2,3}
a
1
2

{1, 2, 3}

a.add(4)
a
1
2

{1, 2, 3, 4}

# a.add({5,6})
# a.add(5,6)
# a.add([5,6])
# 均报错 批量添加用update
1
2
3
4

a.update([2,3,4,5,6])
a
# 批量添加元素
1
2
3

{1, 2, 3, 4, 5, 6}

a.remove(1)
a
1
2

{2, 3, 4, 5, 6}

a.pop()
a
1
2

{3, 4, 5, 6}

# a.remove(7)   
# 删除不存在的元素 报错
# a.remove([4,5])
# 无法如此批量删除
1
2
3
4

7、Python 赋值机制

hza = 123
zhuan = hza
# 同一块内存 id相同 就是一个东西
1
2
3

id(hza)
1

2040543729840

id(zhuan)
1

2040543729840

hza is  zhuan
1

True

zhuan = 456789
id(zhuan)
# zhuan重新赋其他值后就是一个新的变量了 id值就变了
1
2
3

2040629319056

hza is zhuan
1

False

• 常量大值一样，id也不一样(内存不一样 比较大的值不可以复用)
• 常量小值一样，id一样(比较小的值可以复用)

han=12345
zhuan=12345
print(id(han))
id(zhuan)
1
2
3
4

2040629319376
2040629318736

a=1
b=1
print(id(a))
id(b)
1
2
3
4

2040543537456
2040543537456