pythonisalpha函数计算公式_python基础知识

python基础语法注释 —— #标注的文本

数字整数进制0xa、0o10、0b10

bool，2个值True、False

浮点数1.2、3.1415、-0.12

复数

字符串使用‘ “单双引号引用的字符序列

’’’ “““单双引号，可以跨行、可以在其中自由使用单双引号

在字符串前面加上r前缀，表示该字符串不做特殊的处理

转译序列\\ \t \r \n \' \"

前缀r，把里面的所有字符当普通字符对待

缩紧约定使用4个空格缩紧

续行在行尾使用\

如果使用各种括号，认为括号内是一个整体，内部跨行不用\

标识符一个名字，用来指代一个值

只能字母、下划线和数字

只能以字母或下划线开头

不能是python的关键字，如def、class

python是区分大小写的

约定：

不允许使用中文

不允许使用歧义单词，如class_

不要随便使用下划线开头的标识符常量一旦赋值就不能改变值的标识符

python中无法定义常量

字面常量一个单独的量，如12、‘abc’

变量赋之后，可以改变值的标识符

python是动态语言、强类型语言

运算符算数运算符+ - * / % **

自然除/结果是浮点数，整除//。

位运算符& | ~ ^ 《 》

12，0xc，0o14，0b1100～12等于多少？

比较运算符与 或 非 and or not

短路运算符and如果第一表达式为False，后面没必要计算 都为False

or 如果第一表达式为True，后面没必要计算 都为true

赋值运算符a = min(3，5)

+= -= *= /= %=

x=y=z=10

成员运算符in

not in

身份运算符is

is not

运算符优先级别(由高到低)：算数>位运算>身份>成员>逻辑

表达式由数字、符号、括号变量等的组合算数表达式

逻辑表达式

赋值表达式python中，赋值即定义

内存管理变量无须事先声明，也不需要指定类型动态语言特性

程序控制顺序按照先后顺序一条条执行

分支根据不同情况判断条件满足执行某条件下语句

循环条件满足就反复执行，不满足就不执行或不再执行

单分支结构if语句

if condition:

代码块

condition必须是一个bool类型，这个地方有一个隐式转换bool(condition)

if 1<2:

print('1 less than 2')代码块False等价布尔值，相当于bool

空集合

多分支结构if…elif…else语句： if condition: 代码块1 elif condition: 代码块2 …… else: 代码块

分支嵌套举例

In [1]: score = 80

In [2]: if score < 0:

...: print('wrong')

...: else:

...: if score ==0:

...: print('egg')

...: elif score <= 100:

...: print('right')

...: else:

...: print('too big')

...:

right

循环——while语句语法

while cindition:

block

- [ ]当条件满足(即condition为True)进入循环体，执行block

循环——for语句语法

for element in iteratable：

block

当可迭代对象中有元素可以迭代，进入循环体，执行blockrange函数

举例 打印1—10

for i in range(10):

print(i+1)

循环——continue语句中断当前循环的当次执行，继续下一次循环

举例：计算10以内偶数(for循环)

for i in range(10):

if i%2 ==0:

print(i)

循环break语句终止当前循环

举例：计算100以内的被7整除的前20个数(for循环)

count =0

for i in range(0,100,7):

print(i)

count +=1

if count >=20:

break

列表列表是由若干元素组成，列表内每个个体称为元素

元素可以是任意对象(数字、字符串、对象、列表等)

列表内元素是有序的可以使用索引

使用[ ]表示

列表是可变的

列表索引访问

索引，也叫下标

正索引：从左到右，从0开始为列表中每一个元素编号

负索引：从右到左，从-1开始

正索引不可以超界，否则引发异常IndexError

列表通过索引访问

list[index] #index就是索引，使用中括号访问。

列表查询

index(value，[start,[stop]])

count(value) #返回列表中匹配value的次数

len(list) #返回列表元素个数

通过值value从指定区间查找列表的元素是否匹配

匹配第一个就立即返回索引

>>> lis = [1,2,3,2,3,5,2]

>>> lis.index(2)

1

>>> lis.index(2,1)

1

>>> lis.index(2,2)

3

>>> lis.index(2,-1)

6

列表元素的修改(索引访问修改)

list[index] = value #注意索引不要超界

列表增加：append(object)

列表尾部追加元素，返回none，意味着没有新的列表产生，属于就地修改。

列表插入元素：insert(index，object)

在指定的索引index位置插入元素object，返回none 无新列表产生，属于就地修改。可以超越上界，属于尾部追加，可以超越下界，属于头部追加。

列表删除元素：

remove(value)从左到右查找第一个匹配value值移除，就地修改

pop(index)不指定索引index，就从尾部弹出一个元素。指定索引index，就从索引处弹出一个元素。

clear()清除列表所有元素，剩余一个空列表。

列表其他操作：

reverse()将列表元素反转，就地修改

sort(key=None，reverse = False) 对列表元素进行排序，就地修改，默认升序。reverse为True，反转，降序。

列表复制：(深、浅复制)

元组tuple

一个有序对元素组成集合，使用( )表示，是不可变对象

元组访问：通过索引访问，正索引、负索引，不可越界。

元组查询：

index(value，[start, [stop]])

count(value)

len(tuple)

元组只读不能修改

字符串

一个字符组成的有序的序列，是字符集合，使用单引号、双引号、三引号引住的字符序列

字符串是不可变对象

字符串定义(初始化)

赋值即定义

举例：

string_letter = 'b'

string_capital_letter = "B"

string_word = "burger"

string_phrase = 'delicious Burger'

string_sentence = "I love burgers."

string_sentence_chinese = '我喜欢汉堡。'

字符串元素访问——下标

支持使用索引访问

In [1]: str1 = 'I love Python.'

In [2]: str1[0]

Out[2]: 'I'

In [3]: str1[7]

Out[3]: 'P'

字符串连接

1. “+”连接，将两个字符串连在一起返回一个新字符串。

In [1]: str1 = 'I love Python.'

In [4]: str2 = 'What about you?'

In [5]: str1+str2

Out[5]: 'I love Python.What about you?'

2. join连接

‘string’.join(iterable) -> str

字符串分割

1.split 将字符串按照分割符分割成若干字符串并返回列表。

split(sep = None , maxsplit = -1)

从左到右,sep指分割字符串缺省下用空白字符串表示，maxsplit只分割次数，-1表示遍历整个字符串。

rsplit 表示从右到左。

In [6]: s1 = "I'm\ta super student."

In [7]: s1.split()

Out[7]: ["I'm", 'a', 'super', 'student.']

In [8]: s1.split('s')

Out[8]: ["I'm\ta ", 'uper ', 'tudent.']

In [9]: s1.split(' ', maxsplit=2)

Out[9]: ["I'm\ta", 'super', 'student.']

2.partition 将字符串按照分割符分割成2段返回这2段和分割符段元组。

partition(sep) ->(head,sep,tail)

rpartition

从左到右，遇到分割符把字符串分割成两部分，返回头、分割符、尾三部分的三元组，如果没有找到分割符，就返回头、两个空元素的三元组。

In [10]: s1 = "I'm\ta super student."

In [11]: s1.partition('s')

Out[11]: ("I'm\ta ", 's', 'uper student.')

In [12]: s1.partition('super')

Out[12]: ("I'm\ta ", 'super', ' student.')

In [13]: s1.partition('abc')

Out[13]: ("I'm\ta super student.", '', '')

In [14]: s1.rpartition('abc')

Out[14]: ('', '', "I'm\ta super student.")

字符串大小写

upper() 全大写

lower()全小写

swapcase()交换大小写

字符串排版

title()标题每个单词都大写

capitalize()首个单词大写

center(width,[fillchar]) width打印宽度，fillchar填充都字符

字符串修改**

replace(old , new [, count])找到匹配替换为新字符串返回替换新串，count表示替换几次，不指明表示全部替换。

In [15]: s2 = 'www.zhihu.com'

In [16]: s2.replace('w','p')

Out[16]: 'ppp.zhihu.com'

In [18]: s2.replace('w','p',2)

Out[18]: 'ppw.zhihu.com'

strip([chars])从字符串两端去除指定的字符集chars中所有字符。如果chars没有指定，去除两边空白字符。

lstrip([chars])从左开始

rstrip([chars])从右开始

In [19]: s3 = "\r\n\t Hello Python\n\t"

In [22]: s3.strip()

Out[22]: 'Hello Python'

In [25]: s = " I am very very very sorry. "

In [26]: s.strip()

Out[26]: 'I am very very very sorry.'

In [28]: s.strip('r')

Out[28]: ' I am very very very sorry. '

In [29]: s.strip('r y')

Out[29]: 'I am very very very sorry.'

字符串查找**

find(sub, [, star [, end]])在指定区间[star，end]从左到右查找字串sub，找到返回索引，没找到返回-1.

rfind(sub, [, star [, end]]) 从右至左

In [30]: s

Out[30]: ' I am very very very sorry. '

In [31]: s.find('very')

Out[31]: 8

In [32]: s.find('very',5)

Out[32]: 8

idnex(sub [, star, [, end]])在指定区间[star,end]从左到右查找字串sub，找到返回索引，没找到返回“Value Error”

count(sub [,star [,end]])在[star，end]从左到右统计字串sub出现次数。

字符串判断 is

isalnum()是否是字母和数字

isalpha()是否是字母

isisdigit( )是否全部是数字

islower()是否全小写

isupper()是否全大写

isspace()是否只包含空白字符

Python字符串格式化

1.占位符使用

format % values 格式字符串和被格式字符串之间使用%分隔

In [35]: "I am %3d"%(20)

Out[35]: 'I am 20'

In [36]: 'I like %s'%'Python'

Out[36]: 'I like Python'

2.format函数格式字符串语法

“{}{xxx}“.format(*args,**kwargs)

集合

In [37]: s = set('pyhton learn')

In [38]: print(s)

{'p', 'e', 'y', 't', 'o', 'l', 'r', 'h', 'n', 'a', ' '}

集合对象都是可哈希的无序排列的值，集合成员可做字典键

集合不能索引、切片

只能循环遍历，使用in 、not in 判断元素

集合更新

s.add( )添加一个元素

s.update()指定元素

s.remove()删除对象

s.pop()弹出末尾元素

集合关系测试

交集 intersection( )

In [39]: a = set([1,2,3,4,5])

In [40]: b = set([4,5,6,7,8])

In [41]: a

Out[41]: {1, 2, 3, 4, 5}

In [42]: b

Out[42]: {4, 5, 6, 7, 8}

In [43]: a.intersection(b) #求交集

Out[43]: {4, 5}

In [44]: a.union(b) #求并集

Out[44]: {1, 2, 3, 4, 5, 6, 7, 8}

In [45]: a.difference(b) #求差集

Out[45]: {1, 2, 3}

In [46]: a.symmetric_difference(b) #反向交集(对称交集)

Out[46]: {1, 2, 3, 6, 7, 8}

In [47]: a.issuperset(b) #父集

Out[47]: False

In [48]: a.issubset(b) #子集

Out[48]: False

字典

访问字典：使用“变量名[键]”可以直接得到值，

print(dict1['FBI']) # Federal Bureau of Investigation

如果键不存在，也就是我们自己做的字典里没有录进去，Python就会报错：

print(dict1['NATO']) # KeyError: 'NATO'

判断键是否有效：很多时候我们并不知道我们要查的内容是否在字典里，贸然使用肯定不行，那么在使用前我们最好能判断所查的键是否被编进字典了，用in就行了，和列表集合元组一样，

if 'NATO' in dict1:

print(dict1['NATO'])

else:

print('NATO has not been defined in your dictionary.')

# NATO has not been defined in your dictionary.

最后一行是运行上面代码输出的结果，我从运行结果里复制过来的。注意我们只能判断这个键是否存在在字典里，而不能判断某个值是否在字典了。

添加元素：有时候随着时间的推移、程序的运行，我们要更新一开始的字典，

dict1['NATO'] = 'North Atlantic Treaty Organization'

这样就把NATO和NATO的解释添加进字典了，是不是很暴力？如果不信我们可以输出一下试试看，

print(dict1)

# {'NASA': 'National...', 'FBI': 'Federal...', 'CIA': 'Central...', 'NATO': 'North Atlantic Treaty Organization'}

这个结果太长了，我手动把一些内容用省略号表示了，意思达到了就行，NATO被成功添加进字典。

删除字典：使用del可以删除单个元素，要删除多个元素，用逗号隔开就行，

del dict1['NATO'], dict1['NASA']

print(dict1)

# {'FBI': 'Federal Bureau of Investigation', 'CIA': 'Central Intelligence Agency'}

如果删除的元素本身就不在字典里，Python就会报错。

清空字典：clear就行，简单粗暴，

dict1.clear()

print(dict1) # {}

到这里我们辛辛苦苦定义、修改的字典就全没了。

字典的迭代：由于字典也是有一串数据，虽然严格意义上字典没有顺序，我们依然可以像集合一样进行迭代，

dict2 = {'name': 'Alice', 'gender': 'Female', 'age': 19}

for key in dict2:

print("Applicant's {} is {}".format(key, dict2[key]))

结果为：

Applicant's name is Alice

Applicant's gender is Female

Applicant's age is 19

其他的字典使用方法

还能这样定义一个字典，比如我们定义一个和上面dict2一样的字典：

dict3 = dict([('name', 'Alice'), ('gender', 'Female'), ('age', 19)])

如果我们的键都是简短的字符串，也就是单个单词或者连着的单词的时候，我们可以用关键词定义法：

dict4 = dict(name='Alice', gender='Female', age=19)

还有一些字典的函数，简单的有：

len(dict2): 字典dict2有几个元素，即一共有几个键

dict2.keys(): 查看dict2里所有的键，可以在外套一个list()把结果转换为列表

dict2.values(): 查看dict2里所有的值，可以在外套一个list()把结果转换为列表

dict2.items(): 查看dict2里所有的键和值，可以在外套一个list()把结果转换为列表，每个元素为一个元组

dict2.update(dict3): 将dict3添加进dict2里面，dict2被更新，如果有新增的元素则新增进dict2里，如果有重复的键则把dict3的键和值去覆盖dict2的

dict2.has_key(key): 相当于in，查看dict2里是否含有某一特定键

函数

自定义函数有特定的句型特征，

def function_name(param1, param2, ...):

# code here

def add(x,y):

print(x+y)

add(3,5)

8

函数参数：

形参 函数完成其工作所需要的一项信息，

实参 调用函数时传递给函数的信息

传递实参：

位置实参

In [53]: def print_info(name,age):

...: print('Name:%s'%name)

...: print('Age:%d'%age)

In [54]: print_info('jay',28)

Name:jay

Age:28

关键字实参

In [55]: def print_info(name,age):

...: print("My name is %s,I'm %d."%(name,age))

In [56]: print_info(age=18,name = "jin")

My name is jin,I'm 18.

默认值

函数作用域

LEGB

L：local局部作用域，即函数中定义的变量

E：enclosing嵌套的父级函数的局部作用域，即包含此函数的上一级函数局部作用域但不是全局的。

G：golbal 全局变量，就是模块中定义变量。

B：built—in 系统模块变量，如int。

优先级别：L>E>G>B