python的real的函数 python real

判断列表是否为空：

方式一：根据列表长度判断

list_temp = []
if len(list_temp):
     # 存在值即为真
else:
    # list_temp是空的

方式二：

list_temp = []
if list_temp:
    # 存在值即为真
else:
    # list_temp是空的

第二个方法要优于第一个方法，在Python中，False,0,’’,[],{},()都可以视为假。

while语句中：

while A and B: 代表条件A和条件B就要满足
while A or B：代表条件A和条件B任意满足其一均可。

if not语句

如果没有
例如：if not root 如果根节点不存在

return语句

return代表结束整个函数

lambda用法

Python使用lambda来创建匿名函数。

• lambda只是一个表达式，函数体比def简单很多。
• lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
• lambda函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数。
• 虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。

例子：

func=lambda x:x+2
print(func(1))
#3
print(func(2))
#4
 
#以上lambda等同于以下函数
def func(x):
    return(x+2)

map函数

map() 会根据提供的函数对指定序列做映射。
第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。
用法：
map(function, iterable, ...)

• function – 函数
• iterable – 一个或多个序列

可与lambda联合使用
例子：

>>>def square(x) :            # 计算平方数
...     return x ** 2
... 
>>> map(square, [1,2,3,4,5])   # 计算列表各个元素的平方
[1, 4, 9, 16, 25]
>>> map(lambda x: x ** 2, [1, 2, 3, 4, 5])  # 使用 lambda 匿名函数
[1, 4, 9, 16, 25]
# 提供了两个列表，对相同位置的列表数据进行相加
>>> map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])
[3, 7, 11, 15, 19]

enumerate函数

enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。
例子：

seasons = ['Spring', 'Summer', 'Fall', 'Winter']
for index,value in enumerate(seasons)
	print(index,value)
#结果
0, 'Spring' 
1, 'Summer',
2, 'Fall',
3, 'Winter'

add函数

add()方法用于给集合添加元素，如果添加的元素在集合中已存在，则不执行任何操作。
例子：

fruits = {"apple", "banana", "cherry"}
fruits.add("orange") 
print(fruits)
#结果
{'apple', 'banana', 'orange', 'cherry'}

fruits = {"apple", "banana", "cherry"}
fruits.add("apple")
print(fruits)
#结果
{'apple', 'banana', 'cherry'}

set()函数

set() 函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。
返回值：返回新的集合对象。【集合添加元素用add函数】
例子：

x = set('runoob')
 y = set('google')
print(x, y)
# 结果：(set(['b', 'r', 'u', 'o', 'n']), set(['e', 'o', 'g', 'l']))   # 重复的被删除

res = set()
res.add("apple")

zip函数

zip() 函数将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。
返回值：元组列表
例子：

>>>a = [1,2,3]
>>> b = [4,5,6]
>>> c = [4,5,6,7,8]
>>> zipped = zip(a,b)     # 打包为元组的列表
[(1, 4), (2, 5), (3, 6)]
>>> zip(a,c)              # 元素个数与最短的列表一致
[(1, 4), (2, 5), (3, 6)]
>>> zip(*zipped)          # 与 zip 相反，可理解为解压，返回二维矩阵式
[(1, 2, 3), (4, 5, 6)]

index函数

index() 函数用于从列表中找出某个值第一个匹配项的索引位置。
语法：list.index(x[, start[, end]])例子：

aList = [123, 'xyz', 'runoob', 'abc']
print "xyz 索引位置: ", aList.index( 'xyz' )
print "runoob 索引位置 : ", aList.index( 'runoob', 1, 3 )
#结果
#1
#2

count函数

count() 方法用于统计字符串里某个字符出现的次数。可选参数为在字符串搜索的开始与结束位置。
语法：str.count(sub, start= 0,end=len(string))例子：

str = "this is string example....wow!!!";
sub = "i";
print(str.count(sub, 4, 40))
#结果 2
sub = "wow";
print(str.count(sub))
#结果  1

split函数

split() 通过指定分隔符对字符串进行切片，如果参数 num 有指定值，则分隔 num+1 个子字符
返回值：返回分割后的字符串列表。
例子：

s = "I am a student"
print(s.split(" "))
# 结果 ['I','am','a','student']

join函数

join()函数：用于将序列中的元素以指定的字符连接生成一个新的字符串。
语法： ‘sep’.join(seq)
参数说明
sep：分隔符。可以为空
seq：要连接的元素序列、字符串、元组、字典
上面的语法即：以sep作为分隔符，将seq所有的元素合并成一个新的字符串
返回值：返回一个以分隔符sep连接各个元素后生成的字符串

列表转字符串

arr = [1,2,3]
string = ','.join(str(i) for i in arr)

arr = [1,2,3]
b = []
for i in arr:
	b.append(str(i))
string = ',',join(b)
# b: ['1','2','3']
# string: 1,2,3

list sort方法

sort() 函数用于对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数。该方法没有返回值，但是会对列表的对象进行排序
语法：
list.sort( key=None, reverse=False)例子：

numbers = [3,5,1,4,2]
numbers.sort()
print(numbers)
# 结果：[1,2,3,4,5]

vowels = ['e', 'a', 'u', 'o', 'i']
# 降序
vowels.sort(reverse=True)
print(vowels)
# 结果：['u', 'o', 'i', 'e', 'a']

# 指定第二个元素排序
def takeSecond(elem):
    return elem[1]
random = [(2, 2), (3, 4), (4, 1), (1, 3)]
random.sort(key=takeSecond)
print ('排序列表：', random)
# 结果：[(4, 1), (2, 2), (1, 3), (3, 4)]

sorted函数

sorted() 函数对所有可迭代的对象进行排序操作。
返回值：返回重新排序的列表。
例子：

a = [5,7,6,3,4,1,2]
b = sorted(a)  
print(b)
# 结果：[1,2,3,4,5,6,7]

sort 与 sorted 区别：
sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。
list 的 sort 方法返回的是对已经存在的列表进行操作，无返回值，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

list reverse函数

reverse() 函数用于反向列表中元素。
语法：list.reverse()返回值：该方法没有返回值，但是会对列表的元素进行反向排序。
例子：

aList = [123, 'xyz', 'zara', 'abc', 'xyz']
aList.reverse()
print(aList)
# 结果：['xyz', 'abc', 'zara', 'xyz', 123]

reversed函数

reversed 函数返回一个反转的迭代器。
语法：reversed(seq)返回值：返回一个反转的迭代器。

# 字符串
seqString = 'Runoob'
print(list(reversed(seqString)))
 
# 元组
seqTuple = ('R', 'u', 'n', 'o', 'o', 'b')
print(list(reversed(seqTuple)))
 
# range
seqRange = range(5, 9)
print(list(reversed(seqRange)))
 
# 列表
seqList = [1, 2, 4, 3, 5]
print(list(reversed(seqList)))

# 结果：['b', 'o', 'o', 'n', 'u', 'R']
['b', 'o', 'o', 'n', 'u', 'R']
[8, 7, 6, 5]
[5, 3, 4, 2, 1]

sum函数

python内置函数sum() 方法对系列进行求和计算。
语法：sum(iterable[, start]) iterable – 可迭代对象，如：列表、元组、集合。
start – 指定相加的参数，如果没有设置这个值，默认为0。
例子：

>>>sum([0,1,2])  
3  
>>> sum((2, 3, 4), 1)        # 元组计算总和后再加 1
10
>>> sum([0,1,2,3,4], 2)      # 列表计算总和后再加 2
12

endswith函数

endswith() 方法用于判断字符串是否以指定后缀结尾，如果以指定后缀结尾返回True，否则返回False。可选参数"start"与"end"为检索字符串的开始与结束位置。
语法：str.endswith(suffix[, start[, end]]) suffix – 该参数可以是一个字符串或者是一个元素。
start – 字符串中的开始位置。
end – 字符中结束位置。
返回值：如果字符串含有指定的后缀返回True，否则返回False。
例子：

str = "this is string example....wow!!!";
suffix = "wow!!!";
print(str.endswith(suffix,20)) 
suffix = "is";
print(str.endswith(suffix, 2, 4))
print(str.endswith(suffix, 2, 6))
# 结果：True
True
False

values_count函数

value_counts()是一种查看表格某列中有多少个不同值的快捷方法，并计算每个不同值有在该列中有多少重复值。
value_counts()在Series的用法：

import pandas as pd
import numpy as np
from pandas import DataFrame
from pandas import Series
s1=Series(["timo","mike","anni","timo"])
s1.value_counts()
# 结果
timo    2
mike    1
anni    1
dtype: int64

value_counts()在DataFrame的用法：

import pandas as pd
df = pd.DataFrame({'区域' : ['西安', '太原', '西安', '太原', '郑州', '太原'], 
                  '10月份销售' : ['0.477468', '0.195046', '0.015964', '0.259654', '0.856412', '0.259644'],
                  '9月份销售' : ['0.347705', '0.151220', '0.895599', '0236547', '0.569841', '0.254784']})
print(df)
print(df['区域'].value_counts())
# 结果
太原  3
西安  2
郑州  1
Name：区域  dtype: int64

如果想升序排列，设置参数 ascending = True：

abs函数

abs() 函数返回数字的绝对值。
例子：

print(abs(-200))
# 200

min函数字符串比较大小

字符串比较大小是按位比较，两个字符串第一位字符的ascii码谁大，字符串就大，不再比较后面的；第一个字符相同就比第二个字符串，以此类推，需要注意的是空格的ascii码是32，空（null）的ascii码是0。
例子：

str = ["flower", "flow", "flight"]
min_str = min(str)
print(min_str)
# 结果：flight

通过命名参数key，指定取最值方法
min(x,key=len)：传入了长度参数，根据字符长度取最小值
例子：

str = ["flower", "flow", "flight"]
min_str = min(str,key=len)
print(min_str)
# 结果：flow

get函数

Python 字典(Dictionary) get() 函数返回指定键的值，如果值不在字典中返回默认值。
语法：dict.get(key, default=None)

• key – 字典中要查找的键。
• default – 如果指定键的值不存在时，返回该默认值。

返回值：返回指定键的值，如果值不在字典中返回默认值None。
例子：

dict = {'Name': 'Zara', 'Age': 27}
print(dict.get('Age'))
print(dict.get('Sex', "Never"))
# 结果
27
Never

round函数

round() 方法返回浮点数x的四舍五入值
语法：round(x,n)

• x – 数值表达式。
• n – 数值表达式，表示从小数点位数

返回值：返回浮点数x的四舍五入值
例子：

print(round(2.25,1))
print(round(7.869,2))
# 结果
2.2
7.87

另一种保留小数写法

print("%.1f" % 0.13333)   # 保留一位小数，0.1
print("%.3f" % 0.25789)   # 保留三位小数，0.258

拓展：保留百分比小数点后几位

print("{:.0%}".format(42/50))  # 不显示小数位，84%
print("{:.3%}".format(42/50))  # 显示小数点后两位 84.000%

isinstance()和issubclass()函数

isinstance（object，classinfo），用于判断object是否是classinfo的一个实例，或者object是否是classinfo类的子类的一个实例，如果是返回True.
issubclass（class，classinfo），用于判断class是否是classinfo类的子类，如果是返回True.

"//"符号

“//”代表取商。

a = 10
b = 3
c = a//b 
print(c)
# 结果：3

open读取文件

使用open方法打开文件,语法如下：
open(文件名，访问模式) “r”,“w”,“a”,“rb”,“wb”,“ab”：指定对文件打开方式即文件内容操作方式，即只读，可写，追加，二进制读，二进制写，二进制追加

read读取文件

read()读整个文件；
readline()每次读出一行内容；
readlines()读取文本中所有的行

pandas生成csv文件

利用pd.DataFrame方法先将数据转换成一个二维结构数据，再使用to_csv方法生成csv文件
dataframe.to_csv(生成的文件路径,index=False（是否加索引号）,sep=’,’（以逗号为分隔符）)

dataframe = pd.DataFrame({'content':text,'y':label_list})
dataframe.to_csv('new.csv',index=False,sep=',')

pandas读取excel文件

data = pandas.read_excel("area.xlsx")
datalist = data.values.tolist()