python基础

最新推荐文章于 2023-02-07 20:27:33 发布

JenniferZeng

最新推荐文章于 2023-02-07 20:27:33 发布

阅读量388

点赞数

文章标签： python

本文链接：https://blog.csdn.net/jenniferzgh/article/details/106195106

版权

IDLE快捷键

快捷键	说明
ALT+N ALT+P	查看历史命令上一条下一条
Ctrl+F6	重启shell
CTRL+[	代码缩进
CTRl+]	取消缩进
F1	打开帮助文档
Alt+M	打开该模块的py源码
Alt+C	打开类浏览器，方便在源文件中的各个方法体中切换
F5	运行程序

idle特殊符号

符号	例子	意义
#	#这是单行注释	单行注释
''' '''	''' 这是多行注释 '''	多行注释
\	>>>a=[10,20,30,\ 40,50]	行连接符

海龟画图turtle（图形化程序设计）

#导入turtle模块
import turtle
#设置画笔粗细
turtle.width(10)
#显示箭头
turtle.showturtle()
#写字符串
turtle.write("曾贵花")
#前进300像素
turtle.forward(300)
#设置画笔颜色
turtle.color("red")
#箭头旋转90度
turtle.left(90)
#去到坐标（0，50）
turtle.goto(0,50)
#抬笔
turtle.penup()
#下笔
turtle.pendown()
#画圆
turtle.circle(100)

python基础

1.堆放对象，栈放变量

2.查关键字：先输入help（），再输入keywords，quit退出

3.查关键字或者相关模块的说明，可以按F1

4.命名规则

类型	注意	例子
模块和包名	全小写，多个单词之间用_连接	math
函数名	全小写，多个单词间用_连接	my_name
类名	首字母大写	MyName
常量	全大写

变量注意事项

1.先赋值后使用

2.删除变量del a

3.同一个对象可以赋值给多个变量，如a=4;b=4或a=b=4

4.系列解包赋值：a,b,c=4,5,6相当于a=4;b=5;c=6

#系列解包赋值用于变量交换
>>>a,b=1,2
>>> a,b=b,a
>>> print(a,b)

5.python常量是可以被修改的，只是逻辑上不做修改

数据运算

运算	加等	浮点数除法	整数除法	乘法	幂运算	取余数	同时得到商和余数
方法	+=	/	//	*	**	%	divmod()
例子	a +=2	a=8/4	a=8//4	a=8*4	2**2	5%2	divmod(5,2)
结果	相当于a=a+2	2.0	2	32	4	1	2,1

注意：零不能是除数

浮点数加整数等于浮点数

+=中间不要加空格

逻辑运算

运算符	运算	方法	例子	结果
and，or，not	或者	or	x or y	x为true，返回true x为false，返回y
	与	and	x and y	x为true，则返回y x为false，返回false
	非	not	not x	x为true，返回false x为false，返回true
\| ^ &	或	\|	a=0b11001 b=0b01000 c=a\|b	有1为1 0b11001
	亦或	^	a=0b11001 b=0b01000 c=a^b	相同为1，不同为0 0b01110
	与	&	a=0b11001 b=0b01000 c=a&b	都为1为1，其中不为1为零 0b01000
>>=	除等	>>=	a=8 a>>=3	也就是a=a>>3 a=8*2^3=1
<<=	乘等	<<=	a=5 a<<=3	也就是a=a<<3 a=5*2^3=40

同一运算符

运算	is	is not	==
例子	x=1000 y=1000 x is y a=10 b=10 x is y	x is not y	x == y
解释	比较对象地址是否相等		判断对象的值是否相等
结果	false true	x为true，则返回y x为false，返回false	x为true，返回false x为false，返回true

注意：[-5,256]这个范围内只要数值相同，用is判断都为true

整数

类型	二进制	八进制	十六进制	整数	打印为二进制	右移	左移
方法	0b或0B	0o或0O	0x或0X	int()	bin()	>>	<<
例子	0b101	0o10	0xff	int(9.9) int("234") int(true)	bin(17)	a=4 a>>2	a=3 a<<2
输出	5	8	255	9 234 1	'0b10001'	2 右移1相当于除2的1次幂	12 左移1相当于乘2的1次幂左移2相当于乘2的2次幂

注意：python2中整数大小为-2^31到2^31，python3中则是任意大小，无限制

浮点数

作用	转换为浮点数	转换为浮点数	将浮点数四舍五入
方法	float()	科学计数法	round()
例子	float(3) float("233")	314E-2	round(3.56)
输出	3.0 233.0	3.14	4

格式化

数字	格式	例子	输出	描述
3.1415926	{:.2f}	a=“我{0:.2f}岁” a.format(3.1415926)	我3.14岁	保留两位小数
	{:+.2f}		我3.14岁	带符号保留两位小数
	{:.0f}			不带小数

时间表示

计算机时间是从1970.01.01开始

time.time()可以查看过了多长时间（秒）

>>> import time
>>> time.time()
1589799144.0140672
>>> b = int(time.time())
>>> b
1589799241
>>> totalMinutes = b//60
>>> totalMinutes
26496654
>>> totalHours = totalMinutes//60
>>> totalHours
441610
>>> totalDays = totalMinutes//24
>>> totalDays
1104027
>>> totalyears = totalDays//365
>>> totalyears
3024

多点坐标计算两点距离

import turtle
import math

x1,y1 = 200,200
x2,y2 = 200,-200
x3,y3 = -200,-200
x4,y4 = -200,200

turtle.penup()
turtle.goto(x1,y1)
turtle.pendown()
turtle.goto(x2,y2)
turtle.goto(x3,y3)
turtle.goto(x4,y4)

distance=math.sqrt((x1-x4)**2+(y1-y4)**2)
turtle.write(distance)

字符串

操作	作用	方法	例子	结果
转化	十进制数转化为字符	chr()	chr(66)	'B'
	字符转转化为Unicode	ord()	ord("A") ord("花")	65 33457
	数字转为字符串	str()	str(5.20)	'5.2'
提取	提取字符串	[起点，终点，步长]	a='abcdefghijk' a[0] a[1,5,2]	a b,d
替换	字符串替换	replace()	a='abcdefghijk' a.raplace(“c”,“花”)	ab花defghijk a仍然是a
切割	将字符串切割为	slice()	a="i am jennifer" a.splice()	['i','am','jennifer']
合并	将字符串合并为	join()	a=['i', 'am', 'jennifer'] >>> '*'.join(a)	'iamjennifer'
查找	字符串长度	len()	a="abcdae" len(a)	6
	以指定字符串开头	startswith()	a="abcdae" a.startswith('b')	false
	以指定字符串结尾	endswith()	a="abcdae" a.endswith('e')	true
	第一次出现指定字符串的位置	find	a="abcdae" a.find(a)	0
	最后一次出现指定字符串的位置	rfind	a="abcdae" a.rfind(a)	4
	指定字符串出现了几次	count()	a="abcdae" a.conut('a')	2
	所有字符全是字母或数字	isalnum()	a.isalnum()	true
去掉	去掉首尾指定信息	strip()	a="abc" b=" abc " a.strip('*') b.strip()	abc
	去掉字符串左边的指定信息	lstrip()	a="abc" a.lstrip('*')	'abc*'
	去掉字符串右边的指定信息	rstrip()	a="abc" a.rstrip('*')	'*abc'
大小写转换	首字母大写	captalize()	a="i am A winner" a.captalize()	I am A winner
	每个单词首字母大写	title()	a.title()	I Am A Winner
	所有字符转成大写	upper()	a.upper()	I AM A WINNER
	所有字符转成小写	lower()	a.lower()	i am a winner
	所有字符大写变小写，小写变大写	swapcase()	a.swapcase()	I IM a WINNER
格式排版	居中	center()	a="zeng" a.center(10,*) a.center(10)	*zeng* zeng
	居左	Ijust()	a.ljustr(10,*) a.ljust(10)	zeng****** zeng
	居右	rjest()	a.rjest(10,*) a.rjest(10)	******zeng zeng
判断	是否全为字母或数字	isalnum()	a="123aa" a.isalnum()	true
	是否只由字母组成（含汉字）	isalpha()	a="abs曾" a.isalpha()	true
	是否只由数字组成	isdigit()	a.isdigit()	false
	是否为空白符	isspace()	a.isspace()	false
格式化	格式化字符串	format()	a="名字是：{0}，年龄是{1}" a.format("曾XX",18) a="名字是：{name}，年龄是{age}" a.format(name="曾XX"，age=“18”)	名字是：曾XX，年龄是18
格式化	格式化字符串	format()	^居中对齐 <居左对齐 >居右对齐 a="名字是：{0}，年龄是{1:*^8}" a.formmat('曾XX',666)	用填充到一共八个字符，居中对齐名字是：曾XX，年龄是666**

转义字符

作用	续行符	换行	反斜杠	退格	横向制表符	回车	引号
方法	\	\n	\\	\b	\t	\r	\' \"
例子	a=[10,11,12\ 13,14,15]	a="I\nlove\nyou" print(a)	b="c:\\a.\\b" print b
结果	a=[10,11,12,13,14,15]	I love you	c:\a.\b

从控制台读取字符串

myname = inpu("请输入名字")

注意：若字符串只由下划线数字和字母组成，会启用字符串驻留机制

a=“abc_123”

b="abc_123"

a is b为true

a=“abc#”

b="abc#"

a is b为false

可变字符串

>>> import io
>>> s="hello,sir"
>>> sio=io.StringIO(s)
>>> sio.getvalue()
'hello,sir'
>>> sio.seek(7)
7
>>> sio.write('g')
1
>>> sio.getvalue
<built-in method getvalue of _io.StringIO object at 0x03B7FB68>
>>> sio.getvalue()
'hello,sgr'

[]列表list

操作

方法

例子

结果

创建

[]

a=[10,20,'aa']

[10,20,'aa']

list

a=list()

a=list("abcd")

[]

["a","b","c","d"]

list+range创建整数数组

range(start,end,stept)

a=list(range(5))

b=list(range(3,15,2))

a=[1,2,3,4,5]

b=[3,5,7,9,11,13]

包括start不包括end，步长决定多少距离取一个

推导式

a=[x*2 for x in range(5) ]

a=[x*2 for x in range(10) if x%9==0]

a=[0,2,4,6,8]

a=[a,18]

添加

append()

在列表尾部添加，不产生新对象

a=[20,40]

a.append(80)

[20,40,80]

在列表尾部添加元素，产生新对象

a=[20,40]

a=a+[80]

[20,40,80]

extend()

在列表尾部添加列表，不产生新对象

a=[20,40]

a.extend([90,100])

[20,40,90,100]

insert(index,value)

插入元素到任意位置,不产生新对象

a=[20,40]

a.insert(1,100)

乘法扩展

a=[20,40]

b=a*3

[20,40,20,40]

删除

del

删除指定位置元素

a=[10,20,30]

del a[0]

[20,30]

pop()

删除并返回指定位置元素，默认删除最后一个元素

a=[10,20,30]

a.pop()

a.pop(0)

[10,20]

[20]

remove()

删除首次出现的指定元素,元素不存在抛出异常

a=[10,20,20,30]

a.remove(20)

[10,20,30]

访问

list.[index]

通过索引找元素

a=[10,20,30]

a[0]

list.index(value,start,end)

通过元素找索引

a=[10,20,30,40,50]

a.index(20)

a.index(30,1,3)

list.count(value)

获得元素出现次数

a=[10,10,20]

a.count(10)

len()

返回列表长度

a=[1,2,5]

len(a)

判断是否存在指定元素

a=[10,10,20]

10 in a

true

切片

list[start:end:stept]

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

a[0:4:2]

[1,3]

step为负，从右到左读取

排序

升序

sort()

升序，改原列表，不创新表

a=[10,20,30]

a.sort()

[10,20,30]

sorted()

升序，生成新对象

a=[10,20,30]

b=sorted(a)

b=[10,20,30]

逆序

sort(reverse=True)

a=[10,20,30]

a.sort(reverse=True)

[30,20,10]

reversed()

生成新的迭代器对象

a=[10,20,30]

b=reversed(a)

list(b)

[30,20,10]

[::-1]

产生新的列表对象

a=[10,20,30]

b=a[::-1]

[30,20,10]

打乱顺序

randam.shuffle(list)

import randam

a=[10,20,30]

randam.shuffle(a)

[20,30,10]

返回最大值

max(list)

a=[10,30,20]

max(a)

返回最小值

min(list)

a=[10,30,20]

min(a)

二维列表

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

()元组tuple

操作	方法	例子	解释
创建	()	a=(10,20,30)
	tuple()	b=tuple() b=tuple("abc") b=tuple([1,2,3])
	生成器推导式	s=(x2 for x in range(5)) tuple(s) s=(x2 for x in range(5)) s.__next__() list(s)	[0,2,4,6,8] 0 []
访问	[]	a=(10,20,30) a[0]	10
访问	[:4]	a[:2]	(10,20)
排序	sorted()	sorted(a)
合并为元组	zip() 将多个列表合并为元组并返回zip对象	a=[1,2,3] b=[2,3,4] c=zip(a,b) list(c)	[(1,2),(2,3),(3,4)]

{}字典dict

内容	方法	例子	结果和解释
创建	{}	m={"a":"yang","b":"shang"}	{'a': 'yang', 'b': 'shang'}
	dict()	dict(a="yang",b="shang")	{'a': 'yang', 'b': 'shang'}
	zip()+dict()	a=['name','age'] b=['yang','18'] dict(zip(a,b))	{'name': 'yang', 'age': '18'}
	dict.fromkeys 创建值为空的字典	m=dict.fromkeys(['name','age'])	{'name': None, 'age': None}
访问	[ ] 根据键返回值	a={'name': 'young', 'age': '18'} a['name']	'young' 不存在时不反回东西
	get() 根据键返回值	a={'name': 'young', 'age': '18'} a.get('name') a.get('sex') a.get('sex',‘不存在’)	'young' ‘不存在’ 如果为空时，可以返回null或指定提示
	items() 返回所有键值对	a={'name': 'young', 'age': '18'} a.items()	dict_items([('name', 'young'), ('age', '18')])
	keys() 列出所有键	a.keys()	dict_keys(['name', 'age'])
	values() 列出所有值	a.values()	dict_values(['young', '18'])
	len() 键值对的个数	len(a)	2
添加元素	dict[key]=value 添加一对	a['sex']='女'	键值对原来就有就会被替换，没有就会被添加
添加元素	update() 合并，添加多对	a={'name':'jennifer','age':'18'} b={'name':'jennifer','age':'16','sex':'女'} a.update(b)	b='name':'jennifer','age':'16','sex':'女'}
删除元素	del()	a={'name':'jennifer','age':'18'} del(a['name'])	a={'age':'18'}
	pop()	a={'name':'jennifer','age':'18'} c=a.pop('age')	c='18' 删除并返回值对象
	popitem()	a={'name':'jennifer','age':'18'} a.popitem()	随机删除并返回被删除的对象
序列解包		x,y,z=(10,20,30) x,y,z=[10,20,30] a={'name':'jennifer','age':'18'} x,y,z=a	x=10 x=10 x='jennifer'

r1 = {'name':"高小一",'age':'18','money':'3000','city':'beijin'}
r2 = {'name':"高小二",'age':'19','money':'4000','city':'shanghai'}
r3 = {'name':"高小三",'age':'20','money':'5000','city':'shenzhen'}

tb=[r1,r2,r3]

print(tb[1].get('money'))

for i in range(len(tb)):
    print(tb[i].get('money'))
    
for i in range(len(tb)):
    print(tb[i].get('name'),tb[i].get('age'),tb[i].get('money'),tb[i].\
          get('city'))

{}集合

元素不能重复，只有键

内容	操作	例子	结果
创建	{}	a={1,2,3}	{1,2,3}
转化为集合	set	b=(1,2,3) a=set(b)	a={1,2,3}
添加	add()	a={1,2,3} a.add(9)	a={1,2,3,9}
删除	remove()	a={1,2,3} a.remove(3)	a={1,2}
并集，交集，差集	a={1,3,'young'} b={'he','young'} 并集a\|b 交集a&b 差集a-b	{1, 'young', 3, 'he'} {'young'} {1, 3}

分支

单分支if，双分支if..else，多分支if...elif..elif...else，

循环

类型		例子	结果	分析
if		# 单分支 a = input("请输入a：") if int(a) < 10: print(a)
if...else		# 双分支 b = input("请输入b：") if int(b) > 10: print("超过10") else: print("不超过10")
		print(b if int(b) > 10 else "小于10")
if..elif...else		c = input("请输入c：") if 0 < int(c) < 3: print('0-3') elif 4 < int(c) < 6: print("4-6") else: print("6以上")
if...else嵌套循环		# if..else嵌套 d = input("请输入d：") if 0 < int(d) < 100: if 0 < int(d) < 10: print("0-10") elif 11 < int(d) < 20: print("11-20") else: print("20-100") elif 100 < int(d) < 102: print("100-102") else: print("大于102")
while		e = 1 while e <= 10: e += 1 print(e)
for循环	循环元组()	for x in (20, 30, 40): print(x*3)
	循环字符串	for x in 'abcdefg': print(x)
	循环+range	for x in range(3, 10, 2): print(x)		range用来产生指定范围的数字序列 range(start,end,stept)
	循环字典{}	m = {"name": "jennifer", "age": "12"} for x in m: print(x) for x in m.items(): print(x) for x in m.keys(): print(x) for x in m.values(): print(x)
for嵌套循环		for x in range(5): for n in range(5): print(int(x), end='\t') print("\n")

'''
00000
11111
22222
33333
44444
'''
for x in range(5):
    for n in range(5):
        print(int(x), end='\t')
     print("\n")

#99乘法表
for x in range(10):
    for y in range(x):
        print(x, '*', y+1, '=', x*(y+1), end='\t')
    print("\n")

#打印工资大于1500的人名
li1 = {"姓名": "jennifer", "岗位": "测试", "工资": 1400}
li2 = {"姓名": "young", "岗位": "测试", "工资": 1800}
li3 = {"姓名": "tom", "岗位": "测试", "工资": 1600}
c = [li1, li2, li3]
for item in c:
    if item.get("工资") > 1500:
        print(item["姓名"])

zip()

对多个序列进行迭代，最短序列用完时停止

names = ("zeng","liu","chen")
ages = ("16","17","18")
jobs = ("gongchengshi","ceshi","chanpin")

for name,age,job in zip(names,ages,jobs):
    print("{0}..{1}...{2}".format(name,age,job))

# 相当于

for i in range(3):
    print("{0}...{1}...{2}".format(names[i],ages[i],jobs[i]))

推导式

a = [i for i in range(10)]
print(a)

b = [i*2 for i in range(10)]
print(b)

c = [i for i in range(10) if i%3==0]
print(c)


# 字典推导式
s = "i love you,i love you"
m = {i:s.count(i) for i in s}
print('生成字典:',m)

# 生成器推导式（生成元组，一次性）
t = (i for i in  range(5))
print('第一次生成元组：',tuple(t))
print('第二次生成元组:',tuple(t))

函数

内容	分类	例子	解释
参数类型	位置参数（调用时）	def test2(a,b,c,d): print(a,b,c,d) test2(1,2,3,4)	位置参数必须按顺序
	命名参数（调用时）	def test2(a,b,c,d): print(a,b,c,d) test2(c=3,a=1,b=2,d=4)	命名参数顺序可以随意
	默认值参数（定义时）	def test3(b,d,a=1,c=3): print(a,b,c,d) test3(2,4)	默认值参数要放后面，例子中a,b是默认值参数，要放后面
	可变参数（定义时）	def test4(a,b,*c): print(a,b,c) test4(8,9,10,11)	*c是元组
	可变参数（定义时）	def test4(a,b,**c): print(a,b,c) test4(8,9,name="young",age="18")	**c是字典
	强制命名参数 (调用时)	def test4(**a,b,c): print(a,b,c,) test4(name="young",age="18",b=1,c=2)	在可变参数后面增加新的参数必须强制命名
参数对象类型	可变对象	a = [1,2] def fun1(m): m.append(3) print(m) print(id(m)) print(id(a)) print(a) fun1(a)	a是可变对象，可以看到被改变了，浅拷贝，会影响源对象
	不可变对象	b = 10 def fun2(x): print("函数2内打印对象地址",id(x)) x+=10 print("函数2内打印对象地址",id(x)) print(id(b)) fun2(b) print(id(b))	深拷贝，不会影响源对象
	可变对象内含不可变对象	a =(10,20,[5,6]) print("a:",id(a)) def test1(m): print("m:",id(m)) m[0]=20 m[2][0]=20 print(m) print("m",id(m)) test1(a) print("a:",id(a),a)	（）元组是不可变对象，不能更改， m[0]=20会报错（）内的[]列表是可变对象，

可变对象：列表，字典

不可变对象：int，flot，字符串，元组，布尔值

# 传递可变对象
a = [1,2]
def fun1(m):
    m.append(3)
    print(m)
    print(id(m))
print(id(a))
print(a)
fun1(a)

# 传递不可变对象
b = 10
def fun2(x):
    print("函数2内打印对象地址",id(x))
    x+=10
    print("函数2内打印对象地址",id(x))
print(id(b))
fun2(b)
print(id(b))

浅拷贝和深拷贝

可变对象-浅拷贝：会影响源对象

不可变对象-深拷贝：不会影响源对象

lambda表达式

语法：lambda arg1,arg2,arg3...:<表达式>

arg1相当于参数，<表达式>相当于函数体

例子

函数表达方法

调用

f = lambda a,b,c:a+b+c

f(a,b,c):
return a+b+c
print(f(1,2,3))

print(f(1,2,3))

a = [lambda a:a*2,lambda b:b*3,lambda c:c*4]

test01(a):
return a*2

test02(b):
return b*2

test03(c):
return c*2
a = [test01,test02,test03]
b = a[0](6)

b = a[0](6)
print(b)

eval()

将字符串当成是表达式来执行并返回结果

语法：eval(source,globals,locals)

#不需要传参
eval("print('abcd')")

s="print('abcd')"
eval(s)

#传参
dict1 = dict(a=10,b=200)
eval("a+b",dict1)

递归函数

在函数内部自己调用自己

JenniferZeng

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
python基础

IDLE快捷键快捷键说明 ALT+N ALT+P 查看历史命令上一条下一条 Ctrl+F6 重启shell CTRL+[ 代码缩进 CTRl+] 取消缩进 F1 打开帮助文档 Alt+M 打开该模块的py源码 Alt+C 打开类浏览器，方便在源文件中的各个方法体中切换 F5 运行程序 ...
复制链接

扫一扫