python
缩进
内置常量（Built-in Constants）
内置函数（Built-in Functions） :简称BIF
#BIF函数查询 前面两个下划线 _ , 后面两个下划线 _ ,总共四个下划线
dir(__builtins__)
#查询函数用法
help(input)
#Python 中不能把两个完全不同的东西加在一起，比如说数字和文本,文本加数字没有意义，但是文本乘以数字，可以看做是将文本翻倍
print('pengyy ' * 5) #可以正常执行
>>> print('pengyy ' * 5)
pengyy pengyy pengyy pengyy pengyy
print('pengyy ' + 5) #报错
>>> print('pengyy ' + 5)
Traceback (most recent call last):
File "<pyshell#27>", line 1, in <module>
print('pengyy ' + 5)
TypeError: can only concatenate str (not "int") to str
#在字符串中嵌入双引号 反斜杠 转义
print('my name is "pengyy"')
print('my name is \'pengyy\'')
print("my name is 'pengyy'")
#添加双引号进行转义，如果需转义的位置较多，可以使用 原始字符串
#原始字符串:只需要在 字符串 前面加上一个英文字母(r)就可以了
>>> str='d:\now\day'
>>> print(str)
d:
ow\day
>>> str='d:\\now\day'
>>> print(str)
d:\now\day
>>> str=r'd:\now\day'
>>> str
'd:\\now\\day'
>>> print(str)
d:\now\day
#原始字符串不能以反斜杠结尾(\)
>>> str = r'C:\Program Files\pengyy\test\'
SyntaxError: EOL while scanning string literal
>>> str = r'C:\Program Files\pengyy\test''\\'
>>> str
'C:\\Program Files\\pengyy\\test\\'
>>> print(str)
C:\Program Files\pengyy\test\
#长字符串 三重引号字符串 三个双引号 或 三个单引号
>>> str="""我的小鱼你醒了，还认识早晨吗？
昨夜你曾经说，愿夜幕永不降临。
你的香腮边轻轻滑落的，是你的泪，还是我的泪？
初吻吻别的那个季节，不是已经哭过了嘛？
我的指尖还记忆着，你慌乱的心跳。
温柔的体香里，那一绺长发飘飘。"""
>>> str='''我的小鱼你醒了，还认识早晨吗？
昨夜你曾经说，愿夜幕永不降临。
你的香腮边轻轻滑落的，是你的泪，还是我的泪？
初吻吻别的那个季节，不是已经哭过了嘛？
我的指尖还记忆着，你慌乱的心跳。
温柔的体香里，那一绺长发飘飘。'''
#对内置函数赋值操作 str='b'
>>> param=12
>>> str(param)
'12'
>>> a=str(param)
>>> print(a)
12
>>> str='b'
>>> str(param)
Traceback (most recent call last):
File "<pyshell#5>", line 1, in <module>
str(param)
TypeError: 'str' object is not callable
------------------------------------------------------------------------------------------
>>> a=0.0000000000000000000000000023
>>> a
2.3e-27
# True 1 ; False 0 ()
>>> True+True
2
>>> True+False
1
>>> False+False
0
>>> True*False
0
#类型转换
int() str() float()
获取变量类型 type() isinstance()
>> a=520
>>> type(a)
<class 'int'>
>>> a='520'
>>> type(a)
<class 'str'>
>>> a=True
>>> type(a)
<class 'bool'>
>>> a=5.20
>>> type(a)
<class 'float'>
>>> a='pengyy'
>>> isinstance(a,str)
True
>>> isinstance(a,int)
False
>>> isinstance(320,int)
True
>>> isinstance(320.00,int)
False
>>> isinstance(320.00,float)
True
>>> isinstance(32,float)
False
>>> isinstance(32,bool)
False
# 常用操作符
# + - * / % ** //
# % 取余数 ； ** 幂运算 ； // 认作为 向下取整(唤作 地板除法)
>>> 5%2
1
>>> 5**2
25
>>> 5//2
2
>>>
#三元操作符
x,y=4,5
if x>y:
small=y
else:
small=x
print (small)
small=x if x<y else y
print(small)
#循环 while for
while 条件:
循环体
for 目标 in 表达式:
循环体
#python3中print函数中的参数end默认值为’\n’，表示换行，改变end的赋值，就不会换行了
text='pengyunyun'
for i in text:
print(i,end=' ')
# while循环 随机数
# random 模块中的 randint() 函数，随机产生一个 int类型的整数
import random;
print("------------我爱工作室")
number=random.randint(1,10)
print("随机产生的数字是: ",number)
flag=True
while flag:
temp=input("请输入理想数字:")
guess=int(temp)
if guess == number:
print("我草，你是我肚子里的蛔虫么")
print("恭喜你，猜中了")
flag=False
else:
if guess > number:
print('猜错了，，，大了大了。。。')
else:
print("小了小了!!!")
print("游戏结束，不玩了!")
#assert 断言
#assert 断言语句和 if 分支有点类似，它用于对一个 bool 表达式进行断言，如果该 bool 表达式为 True，该程序可以继续向下执行；否则程序会引发 AssertionError 错误。
#有读者可能会问，明明 assert 会令程序崩溃，为什么还要使用它呢？这是因为，与其让程序在晚些时候崩溃，不如在错误条件出现时，就直接让程序崩溃。通常，assert 语句用在检查函数参数的属性（是参数是否是按照设想的要求传入），或者作为初期测试和调试过程中的辅助工具。
#assert 断言的执行逻辑是：
if 表达式的值为 True：
程序继续运行；
else： # 表示式的值为 False
程序引发 AssertionError 错误
#break continue
#break终止当前循环 continue 结束本轮循环 继续下一轮循环
# 列表(list) 列表索引值从 0 开始
# append 末尾追加
# extend 末尾追加 ，参数是个列表
# insert 两个参数 第一个参数指定位置，第二个参数指的是插入的元素
# remove del pop 删除元素
# str=['aa','bb','cc','dd','yy'] str1=str str2=str[:]
# str1 str2 都是 str的拷贝，但是两者有所区别
# str1 会随着 str的修改而变动 ， str2 不会随着 str 的变动而变动
str=['aa','bb','cc','dd','yy']
print (str)
number=[1,2,4,5,6,7]
print (number)
mix=[1,2,3,'aa','bb','cc',[4,5,6]]
print(mix)
empty=[]
print(empty)
print(type(mix))
empty.append('dd')
print(empty)
empty.extend([1,2,3])
print(empty)
empty.insert(1,'bb')
print(empty)
empty.insert(0,'aa')
print(empty)
print('从 str 列表删除元素')
str.remove('cc')
print(str)
del str[2]
print(str)
num=number.pop()
print(number)
print(num)
num=number.pop(1)
print(number)
print(num)
# 列表(list) 切片
>>> str=['aa','bb','cc','dd','yy']
>>> str1=str[1:3]
>>> str1
['bb', 'cc']
>>> str2=str[1:]
>>> str2
['bb', 'cc', 'dd', 'yy']
>>> str3=str[:3]
>>> str3
['aa', 'bb', 'cc']
>>> str4=str[:]
>>> str4
['aa', 'bb', 'cc', 'dd', 'yy']
>>>
#列表 取值 调换元素顺序
>>> str=['aa','bb','cc','dd','yy']
>>> temp=str[4]
>>> str[4]=str[0]
>>> str
['aa', 'bb', 'cc', 'dd', 'aa']
>>> str[0]=temp
>>> str
['yy', 'bb', 'cc', 'dd', 'aa']
#列表元素翻转 排序
>>> str=['aa','bb','cc','dd','yy']
>>> str.reverse()
>>> str
['yy', 'dd', 'cc', 'bb', 'aa']
>>> str.sort()
>>> str
['aa', 'bb', 'cc', 'dd', 'yy']
#元组(tuple) 不能被修改
>>> tuple1=(1,2,3,4,5,6,7)
>>> tuple1
(1, 2, 3, 4, 5, 6, 7)
>>> tuple1[2]
3
>>> tuple1[4:]
(5, 6, 7)
>>> tuple1[:4]
(1, 2, 3, 4)
>>> tuple2=tuple1[:]
>>> tuple2
(1, 2, 3, 4, 5, 6, 7)
>>> tuple1[2]=9
Traceback (most recent call last):
File "<pyshell#7>", line 1, in <module>
tuple1[2]=9
TypeError: 'tuple' object does not support item assignment
>>> temp=(1)
>>> type(temp)
<class 'int'>
>>> temp=(1,)
>>> type(temp)
<class 'tuple'>
>>> temp=()
>>> type(temp)
<class 'tuple'>
>>> temp=1,2,3
>>> type(temp)
<class 'tuple'>
>>> temp=(1,2,3)
>>> type(temp)
<class 'tuple'>
>>> temp=1,
>>> type(temp)
<class 'tuple'>
>>> temp=('aa','bb','cc','dd')
>>> temp=temp[:2]+('ee',)+temp[2:]
>>> temp
('aa', 'bb', 'ee', 'cc', 'dd')
# format函数
>>> "{0} are a {1} {2}".format('you','handsome','boy')
'you are a handsome boy'
>>> "{a} are a {b} {c}".format('you','handsome','boy')
Traceback (most recent call last):
File "<pyshell#26>", line 1, in <module>
"{a} are a {b} {c}".format('you','handsome','boy')
KeyError: 'a'
>>> "{a} are a {b} {c}".format(a='you',b='handsome',c='boy')
'you are a handsome boy'
>>> "{0:.1f}{1}".format(27.658,'GB')
'27.7GB'
函数
def 关键字创建函数
#关键字参数
>>> def say(name,words):
print(name + '--->' +words)
>>> say('彭云云','你有病啊')
彭云云--->你有病啊
>>> say('你有病啊','彭云云')
你有病啊--->彭云云
>>> say(words='你有病啊',name='彭云云')
彭云云--->你有病啊
#默认值参数
>>> def say(name='彭云云',words='你有病啊'):
print(name + '--->' +words)
>>> say()
彭云云--->你有病啊
>>> say(name='pengyy')
pengyy--->你有病啊
>>> say('pengyy')
pengyy--->你有病啊
>>> say('你有病啊')
你有病啊--->你有病啊
>>> say(words='你吃多了')
彭云云--->你吃多了
#收集参数(可变参数)
>>> def test(*params):
print(len(params))
print(params)
print(type(params))
>>> test(1,2,'aa','bb',3,4,3.14)
7
(1, 2, 'aa', 'bb', 3, 4, 3.14)
<class 'tuple'>
#既有可变参数，又指定某一特定参数
>>> def test(*params,addr):
print(len(params),addr)
print(params)
print(type(params))
>>> test(1,2,'aa','bb',3,4,5)
Traceback (most recent call last):
File "<pyshell#34>", line 1, in <module>
test(1,2,'aa','bb',3,4,5)
TypeError: test() missing 1 required keyword-only argument: 'addr'
>>> test(1,2,'aa','bb',3,4,5,addr='南京')
7 南京
(1, 2, 'aa', 'bb', 3, 4, 5)
<class 'tuple'>
>>> def test(*params,addr='nnajing'):
print(len(params),addr)
print(params)
print(type(params))
>>> test(1,2,'aa','bb',3,4,5)
7 nnajing
(1, 2, 'aa', 'bb', 3, 4, 5)
<class 'tuple'>
>>> test(1,2,'aa','bb',3,4,5,addr='南京')
7 南京
(1, 2, 'aa', 'bb', 3, 4, 5)
<class 'tuple'>
#函数返回值
# 函数如果没有明确指定返回值，默认返回 None
def sum(a,b):
print(a+b)
aa=sum(2,3)
print(aa)
>>> def sum(a,b):
return a+b
>>> print(sum(1,3))
4
# 函数返回多个值
>>> def test():
return 1,2,3
>>> aa=test()
>>> print(aa)
(1, 2, 3)
>>> type(aa)
<class 'tuple'>
#变量作用域
#global 关键字
#内嵌函数
>>> def fun1():
print("fun1()被调用")
def fun2():
print('fun2()被调用')
fun2()
>>> fun1()
fun1()被调用
fun2()被调用
#闭包(closure)
#python中的闭包从表现形式上定义（解释）为：如果在一个内部函数里，对在外部作用域（但不是在全局作用域）的变量进行引用，那么内部函数就被认为是闭包(closure).
>>> def funx(x):
def funy(y):
return x * y
return funy
>>> a=funx(5)
>>> type(a)
<class 'function'>
>>> b=a(6)
>>> print(b)
30
# nonlocal 关键字
# lambda 表达式
>>> def dx(x):
return 2*x+1
>>> dx(5)
11
>>> lambda x:2*x+1
<function <lambda> at 0x000001B9C95237B8>
>>> g=lambda x:2*x+1
>>> g(5)
11
>>> def add(a,b):
return a+b
>>> add(3,4)
7
>>> lambda a,b:a+b
<function <lambda> at 0x000001B9C9523950>
>>> g=lambda a,b:a+b
>>> g(3,4)
7
浙公网安备 33010602011771号