Python基础

一、基本语法和数据类型

缩进

1.缩进：一行代码开始前的空白区域，表达程序的格式框架。
2.Python对缩进有着强制性要求，通过缩进来控制程序的结构和层次
3.一般用4个空格或1个TAB代表缩进
4.缩进分为：单层缩进和多层缩进

注释

单行注释：

以#开头

#这是单行注释表达方式

多行注释：

三个单引号 三个双引号

'''今天吃啥了
'''
"""准备吃铁板烧
"""

常量与变量

区别

1.存放的值

常量：内存中用于保存固定值的单元、在程序中、常量的值不能发生改变的；

变量：占用内存中一块空间、用来存放变量的值（或地址）、存放的值是可以发生改变的；

2.命名规范

常量命名规范：通常是以全部大写字母进行区分NAME常量、name变量；

变量命名规范：第1个字符必须是大小写字母或下划线开始，不可用数字开头，不能用中文开头。
模块名：全小写字母，不使用下划线。

变量命名方式

普通变量：全小写字母，单词之间用下划线分割，如my_var；
全局常量：全大写字母，单词之间用下划线分割，如MY_CONST；
类名：首字母大写，单词直接连在一起，采用驼峰命名法，如MyClass

标识符和关键字

标识符

标示符就是程序员定义的变量名、函数名、类名等，可以清楚的理解该变量中存储的数据的具体含义

标示符可以由字母、下划线和数字组成 、 不能以数字开头 、 不能与关键字重名

关键字

关键字就是在Python内部已经使用的标识符，具有特殊的功能和含义

Python语言有33个保留字

数据类型

1.整数型

在Python3里，只有一种整数类型int，整型是没有限制大小的，可以当作Long类型使用。

整数4种进制表示形式

十进制：1010, 99, -217
二进制，以0b或0B开头：0b010, -0B101 Byte
八进制，以0o或0O开头：0o123, -0O456
十六进制，以0x或0X开头：0x9a, -0X89

最终是以十进制进行输出

2.浮点数

浮点数可以采用科学计数法表示

使用字母e或E作为幂的符号，以10为基数，格式如下：
a>e<b 表示 a10b
例如：4.3e-3 值为0.0043 4.310-3
3.4e8 3.4108
9.6E5 值为960000.0 9.6105

3.布尔

布尔值使用常量 True 和 False 来表示
在数值上下文环境中，

True 被当作 1，False 被当作 0

print(True+1)  #2

4.复数

与数学中复数的概念一致

z = 1.23e-4+5.6e+89j #1.23*10-4      5.6*1089

z.real 获得实部
z.imag 获得虚部

实部和虚部都是浮点数

5.字符串

概念

字符串：由0个或多个字符组成的有序字符序列
字符串由一对单引号或一对双引号表示
字符串是字符的有序序列，可以对其中的字符进行索引
“hello”----> h e l l o
索引 ------> 0 1 2 3 4

转义字符

1.转义符形成一些组合，表达一些不可打印的含义

转义字符	描述
\(在行尾时)	续行符
\\	反斜杠符号
’	单引号
"	双引号
\b	退格(Backspace)
\000	空
\n	换行
\r	回车

字符串常用运算转换

'''
bin() 转换成二进制 返回一个字符串
oct() 转换成八进制 返回一个字符串
hex() 转换成16进制 返回一个字符串
'''
a =bin(100)
print(a)
print(type(a))b =oct(100)
print(b)
print(type(b))c =hex(100)
print(c)
print(type(c))'''
chr(x)把十进制转换成ASCLL编码字符
ord(x)把ASCLL编码字符转换成十进制
'''
print(chr(64))
print(ord("?"))

字符串大小写转换

#lower转换成小写
Str01 ="AGSSWGD"
print(Str01.lower())
#upper转换成大写
Str02 ="hhvhjvvh"
print(Str02.upper())

#split拆分
Str03 ="I,like,you"
Str04 =Str03.split(",")
print(Str04)
print(type(Str04))
#count计算字符
a =Str03.count("。")
print(a)
#center(宽度，字符)，单个字符
Str05 ="这瓜保熟吗"
Str06 =Str05.center(30,"*")
print(Str06)
#strip 去除的字符
Str07 ="张三李四王五"
Str08 =Str07.strip("张三王五")
print(Str08)

#join(字符) 链接两个字符
Str09 ="203721732723"
b =","
Str10 =b.join(Str09)
print(Str10)
#replace(old,new)旧子串替换成新字串
Str11 ="i,love,you"
Str12 =Str11.replace("you","吴彦辉")
print(Str12)
print(5/2)

格式化

第一种
使用百分号进行格式化输出的方式，用法如下：

%s，表示字符串；
%d，表示整数；
%f，表示浮点数。
%，代表一个占位符

name = "张三"
age = 18
print("%s is %d year old"%(name,age))

注意：
1.字符串和int不能拼接
2.对数据有未知性

格式化：让数据更加明了 商品 价格 口红 399 装备 80 ‘’’
#商品名字为口红的价格是399
#价格名字为商品的口红是399

print("%s名字为%s是%d"%("价格","商品","口红",399))

bug: 占位符必须和参数一一对应，否则，语句不通顺，报错

第二种 用法如下：

<模板字符串>.format(<逗号分隔的参数>)
利用{}为占位符
“{}的爱徒是{}，儿徒是{}”

print("{}的爱徒是{}，儿徒是{}".format("郭德纲","栾云平","郭麒麟"))

二、数据结构

1. list列表

list列表 使用方括号 [] 或 list()创建，元素使用逗号 , 分隔

创建列表

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

常用函数

#求和sum
print(sum(list01)) #21
#统计列表元素长度len
print(len(list01)) #6
#最大值max 最小值min
print(max(list01)) #6
print(min(list01)) #1

1.1 增加

1. list.insert(index,值) 根据下标进行插入数据
2. list.append(值) 在末尾插入
3. list.extend() 将灵异序列元素依次添加到列表

list01.insert(2,9)
print(list01) #[1, 2, 9, 3, 4, 5, 6]
list01.append("abc")
print(list01) #[1, 2, 9, 3, 4, 5, 6, 10]
list01.extend([7,8])
print(list01)

1.2 删除

1. list.pop(index) 删除指定位置的数据
2. list.remove(值) 删除值，但是他删除的是值第一次出现的位置
3. list.clear() 删除所有数据

list01.pop(2)
print(list01)
list01.remove("abc")
print(list01)

1.3 修改

list[index] = 值

list01[5] = "hhh"
print(list01)

1.4 查询

1. 查询所有 --直接打印列表名字
2. 查询单个值 利用[index]进行查询
3. 查询多个值 [start:stop] 左开右闭 小数在前面 正向递增 反向递减 一负一正
   -6 -5 -4 -3 -2 -1
   [1, 2, 3, 4, 5, ‘hhh’]
   0 1 2 3 4 5

print(list01) #[1, 2, 3, 4, 5, 'hhh']
print(list01[4]) #5
print(list01[0:3]) #[1, 2, 3]
print(list01[-6:-3]) #[1, 2, 3]
print(list01[-6:3]) #[1, 2, 3]

常用方法

1. list.reverse() 反转列表元素
2. list.copy() 复制列表元素
3. list.sort(reverse = Ture/False) 排序 默认是升序 reverse = Ture降序 reverse = False 升序
4. list.count() 返回元素出现的次数

list02 = [2,-2,4,5,7,-1,-5,9]
list02.reverse()
print(list02) #[9, -5, -1, 7, 5, 4, -2, 2]
list03 = list02.copy()
print((list03)) #[9, -5, -1, 7, 5, 4, -2, 2]
list02.sort()
print(list02) #[-5, -2, -1, 2, 4, 5, 7, 9]
list02.sort(reverse=True)
print(list02) #[9, 7, 5, 4, 2, -1, -2, -5]
list02.count(5)
print(list02)

2. 元组tuple

元组tuple 是一种序列类型，一旦创建就不能被修改 不能增删改

创建元组

使用小括号 () 或 tuple() 创建，元素间用逗号 , 分隔

#创建
tuple01 = (1,3,5,7,9)
tuple02 = tuple() #空元组()
tuple03 = tuple((2,4,6,8,10))
tuple04 = tuple01 + tuple03 #连接
print(tuple01)
print(tuple02)
print(tuple03)
print(tuple04) #(1, 3, 5, 7, 9, 2, 4, 6, 8, 10)

2.1 查询

1. 查询所有值 直接打印元组名字
2. 查询单个值 [index]
3. 查询多个值 [start:stop] 左开右闭 一负一正

print(tuple01[3]) #7
print(tuple03[1:4]) #(4, 6, 8)
print(tuple03[-4:-1]) #(4, 6, 8)
print(tuple03[-4:4]) #(4, 6, 8)

3. 字典dict

键值对：键是数据索引的扩展[key:value] 字典是键值对的集合，键值对之间无序(没有索引） 采用<font color=“red”

大括号{}和dict()创建，键值对用冒号: 表示 字典类型是“映射”的体现 <字典变量> = {<键1>:<值1>, … , <键n>:<值n>}

创建字典

dict01 = {"张三":18,"李四":20,"王五":40}
dict02 = dict() #空字典
dict03 = dict({"赵六":30,"吴七":15,"钱八":55})
print(dict01)
print(dict02)
print(dict03)

3.1 增加

1. dict01[新的key] = 新的值 添加数据
2. setdefault() 和get类似，如果键不存在于字典中，将会添加键并将值设default=None

dict01["周九"] = 25
print(dict01) #{'张三': 18, '李四': 20, '王五': 40, '周九': 25}
dict01.setdefault("哈哈",77)
print(dict01)

3.2 删除

1. dict.pop(key) 根据key删除一对数据
2. dict.clear() 清除所有数据

dict01.pop("李四")
print(dict01) #{'张三': 18, '王五': 40, '周九': 25}

3.3 修改

只能修改值，不可以修改key
因为key是唯一的，不能重复的，避免出现重复的情况所以不能修改
先根据key拿到值 dict01[“孙策”] 再重新赋值

dict01["周九"] = 66
print(dict01) #{'张三': 18, '王五': 40, '周九': 66}

3.4 查询

1. dict.keys() 查看所有的key(名字)
2. dict.values() 查询所有的value(年龄)

print(dict01.keys()) #dict_keys(['张三', '王五', '周九'])
print(dict01.values()) #dict_values([18, 40, 66])

查询单个值
1.dict[key] 利用key查询value
2.dict.get(key,默认值) 利用key查询value 如果key没有，那么就输出默认值

print(dict03["赵六"]) #30
print(dict03.get("赵六")) #30
print(dict03.get("貂蝉","无此人物")) #无此人物

查询所有值(包括key和value)
1.直接打印字典名
2.dict.items() 迭代方法

print(dict03) #{'赵六': 30, '吴七': 15, '钱八': 55}
print(dict03.items()) #dict_items([('赵六', 30), ('吴七', 15), ('钱八', 55)])

常用方法

1. copy() 复制
2. fromkeys() 创建一个新字典，返回对应的初始值
3. items() 返回一个所有键值对对元组组成的列表
4. keys() 返回一个所有键key组成的列表
5. values() 返回一个所有键值对组成的列表
6. update() 来一次更新多个键值对
7. popitem() 随机返回并删除字典中最后一对键值对
8. k in dict  key在不在字典里面 在输出True ,不在输出False

#复制
dict04 = dict01.copy()
print(dict04) #{'张三': 18, '王五': 40, '周九': 66}
old = ("胡歌","吴彦祖","彭于晏")
#创建新字典
new = dict.fromkeys(old,45)
print("新的字典是：%s"% str(new)) #新的字典是：{'胡歌': 45, '吴彦祖': 45, '彭于晏': 45}
a ={'a':1,'b':2,'c':3,'d':4}
#返回键值对
print(a.items()) #dict_items([('a', 1), ('b', 2), ('c', 3), ('d', 4)])
#返回所有key
print(a.keys()) #dict_keys(['a', 'b', 'c', 'd'])
#返回所有values
print(a.values()) #dict_values([1, 2, 3, 4])
#update更新值
b = {"e":5,"f":6,"g":7}
a.update(b)
print(a) #{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6, 'g': 7}
#返回最后键值对
print(a.popitem()) #('g', 7)
print(a) #{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}
#判断是否在字典类
print("e" in a) #True

4. 集合set

集合是多个元素的无序(没有下标)组合 集合类型与数学中的集合概念一致 集合元素之间无序，每个元素唯一，不存在相同元素
集合元素不可更改，不能是可变数据类型 无序唯一

创建集合

集合用大括号 {} 表示，元素间用逗号分隔
建立集合类型用 {} 或 set()
建立空集合类型，必须使用set()

#创建
set01 = {1,2,3,4,5,6}
set02 = set() #空集合
set03 = set({7,8,9,10})
print(set01)
print(set02) #set()
print(set03) #{8, 9, 10, 7} 无序

空集合set()

空列表 []
空元组 ()
空字典 {}
空集合 set() 原因是字典的创建也是{}，两者冲突了

print(type({})) #<class 'dict'>
print(type(set())) #<class 'set'>

4.1 增加

1. set.add() 添加一个数据 也能添加已有的数据，虽然不报错，但是不显示
2. set01.update(set02) 批量添加数据 把set02添加到set01中

set01.add(-1)
print(set01) #{1, 2, 3, 4, 5, 6, -1}
set01.add(1)
print(set01) #{1, 2, 3, 4, 5, 6, -1}
#
set04 = {"qq","wechat","dy","game"}
set03.update(set04)
print(set03) #{7, 8, 9, 10, 'dy', 'qq', 'wechat', 'game'}

4.2 删除

1. set.discard(值) 删除集合中的值 ,如果数据不存在，不报错
2. set.remove(值) 删除集合中的值,如果没有这个值，会报错KeyError异常
3. set.pop() 随机删除,如果是空集合，则报错KeyError异常
4. set.clear() 清空集合

set05 = {"赵","钱","孙","李","周","吴","郑","王"}
set05.discard("钱")
print(set05) #{'吴', '郑', '周', '孙', '李', '赵', '王'}
set05.remove("王")
print(set05) #{'吴', '郑', '周', '孙', '李', '赵'}
set05.pop()
print(set05) #{'郑', '周', '孙', '李', '赵'}

4.3 修改

集合唯一，不能改变

4.4 查询

直接打印集合名字，不能使用索引进行查询，因为我们集合是无序的

print(set05) #{'赵', '周', '吴', '孙', '郑'}

转换方法

set(x) 把其他数据类型（x）转换成集合类型

Str = "hello"
print(Str) #hello
print(type(Str)) #<class 'str'>b = set(Str)
print(type(b)) #<class 'set'>
print(b) #{'e', 'l', 'o', 'h'}随机

集合的基本运算

并集 符号是 |，返回两个集合的所有值 union()

A,B = {1,3,2,4,5,7,8,0,6},{0,2,4,6}
print(A | B) #{0, 1, 2, 3, 4, 5, 6, 7, 8}
print(A.union(B)) #{0, 1, 2, 3, 4, 5, 6, 7, 8}

差集的符号是 - set01 - set02 set01去掉公共部分的值
set01.difference(set02)

print(A - B) #{1, 3, 5, 7, 8}
print(A.difference(B)) #{1, 3, 5, 7, 8}

交的符号 & 两个的公共部分 set01.intersection_update(set02) /intersection()

print(A & B) #{2, 4}
print(A.intersection_update(B)) #{2, 4}

补集
1.补集的符号 ^ 对称差集
2.并集-交集 = 补集 set01.symmetric_differwnce(set02)
3.除去公共部分，set01和set02的单独部分我都要

print(A ^ B) #{0, 1, 3, 5, 6, 7, 8}
print(A.symmetric_difference(B)) #{0, 1, 3, 5, 6, 7, 8}

集合的包含关系

如果集合A的元素都是另一个集合B的元素，那么A就是B的一个子集。 如果A与B不相同，那么A叫做B的一个真子集 判断是否子集 <=
set02.issubset(set01) 使用“>=”操作符
set01.issuperset(set02)方法来验证一个集合是否包含另一个集合： 真子集可以用符号“<”或者“>”去判断

print( B <= A) #True
print(B.issubset(A)) #True
#
print(A >= B) #False
print(A.issuperset(B)) #True
#
print(B < A) #True
print(A < A) #False

增强符

增强符 打印出来和并交等一样，只不过他是更新s的值, t值不变

1. s |= t
2. s -= t
3. s &= t
4. s ^= t

s,t = {1,2,3,4,5,6},{4,5,6,7,8,9}
print(s | t) #{1, 2, 3, 4, 5, 6, 7, 8, 9}
s |= t
print(s) #{1, 2, 3, 4, 5, 6, 7, 8, 9}
print(t) #{4, 5, 6, 7, 8, 9}

小练习

#创建空列表
list01 = list()
print(list01)
#新增5个元素
list01 =["科比","詹姆斯","邓肯","姚明","欧文"]
print(list01)
#修改第2个元素为 杜兰特
list01[1] ="杜兰特"
print(list01)
#第二个位置增加一个元素 乔丹
list01.insert(1,"乔丹")
print(list01)
#删除第一次出现的元素 科比
list01.remove("科比")
print(list01)
#删除第3位置的元素
list01.pop(3)
print(list01)
#向列表新增数字0
list01.append(0)
print(list01)
#打印0的索引
print(list01.index(0))
#打印输出列表长度
print(len(list01))
#打印输出列表最大索引元素
list01 =["科比","詹姆斯","邓肯","姚明","欧文"]
print(list01.index(max(list01)))
#清空列表
list01.clear()
print(list01)#创建空字典d
d ={}
print(d)
#新增2个键值对元素
d["a"]="1"
d["b"]="2"
print(d)
#修改第二个元素
d["b"]="3"
print(d)
#判断"c"是否是d的键
print("c" in d)
#输出d的长度
print(len(d))
#清空字典d
print(d.clear())#创建集合
set01 ={1,2,3,4,5}
set02 ={2,5,8,4,1}
#输出set01长度
print(len(set01))
#复制set02
set03 =set02.copy()
print(set03)
#并集
print(set01 | set02)
#交集
print(set01 & set02)
#差
print(set01 -set02)
#补集
print(set01 ^ set02)
#s删除元素8
set02.discard(8)
print(set02)
#添加元素6
set02.add(6)
print(set02)
#判断set02是否是set01的子集
print(set02.issubset(set01))

三、内置函数与自定义函数

数字相关的内置函数

#abs 求绝对值的
print(abs(-3))

divmod(x,y) (x//y)商和(x%y)余数，同时输出商和余数 x//y 整除 向下取整 x%y
余数=被除数-除数*商 10%-3=-2

x = 10
y = 3print(divmod(10,3)) #(3, 1)

pow(x,y) 幂 x的y次方 -------x ** y
pow(x,y,z) 先求x的y次方 得到的结果和z进行取余----x**y%z

print(pow(x,y)) #1000
print(pow(x,y,3)) #1
print(pow(2,4,10)) #2**4 = 16  16%10=6

#round(x,f) 四舍五入保留小数

print(round(3.1415926,4))#3.14

#max(x1,x2,…) 返回最大值
#min(x1,x2,…) 返回最小值

print(max(1,2,5,7,4,67))#67
print(min(1,2,5,7,4,67))#1

序列相关的内置函数

all(序列) all()接受一个序列 [] () {} set()都是flase

a =["hello",3.14,4+3j,{"张三":18,"李四":22}]
print(all(a))
b =["hello",3.14,4+3j,{"张三":18,"李四":22},[]]
print(all(b))c=[{}]
print(all(c))

any(x) 任意一个为真返回True，否则为False

d =[{},(),set()]
print(any(d))#False

range(start,stop,step) 返回一个迭代对象
左开右闭 迭代对象（需要list转换才能输出）
start:开始数值
stop:结束数值
step:步长,和间隔不一样

1.省略开始数值,开始数值会被默认成0
2.不能省略结束数值
3.步长可以省略，如果步长不写，默认是1
步长是2，间隔是1
步长是3，间隔是2

a = range(10)
print(a) #range(0, 10)
print(list(a)) #[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]c = range(1,10,2)
print(list(c)) #[1, 3, 5, 7, 9]
d = range(1,10,3)
print(list(d)) #[1, 4, 7]

sorted(x) 升序排序 返回一个列表
reversed(x) 反序排序 返回迭代器

a =[1,2,3,4,5,6]
print(sorted(a))#[1, 2, 3, 4, 5, 6]
#reversed(x) 反序排序
print(list(reversed(a)))#[6, 5, 4, 3, 2, 1]
c = [1,2,3,4,5,6]
print(reversed(c)) #<list_reverseiterator object at 0x0000026D0B74C7C8>

enumerate(x) 可以迭代序号和值：
返回一个迭代对象，输出序号（下标）和值

b =[1,3,6,4,8,0,2,9]
print(list(enumerate(b)))
#[(0, 1), (1, 3), (2, 6), (3, 4), (4, 8), (5, 0), (6, 2), (7, 9)]

slice(start,stop,step) 切片，返回一个切片对象 start：开始数值 stop：结束数值 step：步长
1.步长可以省略，默认是1

a = slice(5,15)
print(a) #slice(5, 15, None)
#把a换成一个迭代对象
b = range(20)[a]
print(b) #range(5, 15)
print(list(b)) #[5, 6, 7, 8, 9, 10, 11, 12, 13, 14]

类型相关的内置函数

int(x)将x转换成整数，舍弃小数部分， 可以把字符串转成整数,数字字符串可以
print(int(“wyh”)) 必须是数字字符串

print(int(3.14)) #3
print("123") #123

float(x)将x转换成小数，增加小数部分 可以把字符串变成小数，必须是数字字符串
print(float(“wyh”))

print(float(19))#19.0
print(float("20"))#20.0

complex(x)将x变成复数，增加虚数部分 数字类型的字符串

print(complex(20))#(20+0j)
print(complex(20.9))#(20+0j)
print(complex("20.9"))#(20+0j)

isinstance(变量,类型) 类型判断,
如果变量和类型一致是true，
不一致是false
类型：Str int float list stuple dict set

a = [1,2,3,4]
print(isinstance(a,list)) #True
print(isinstance(a,int)) #False

自定义函数

定义

· 使用关键字def引导；
· def后面是函数的名称，括号中是函数的参数，不同的参数用逗号“,”隔开，参数可以为空，但括号不能省略；
· 函数的代码块要缩进；
· 用一对"""包含的字符串作为函数的说明，用来解释函数的用途，可省略，在查看函数帮助时会显示；
· 使用关键字 return返回一个特定的值，如果省略，返回None。

def 函数名称(参数1，参数2):

• 代码块

• return

调用

 def add(x,y):sum01 = x+yreturn sum01
print(add(2,3))#5

1.参数

参数可以是0个，也可以是多个
带默认值的参数

调用

1. 可以只传一个参数，那这个参数就是x，y是默认值20
2. 如果传入两个参数，那么默认值不起作用

def jia(x,y=20):a=x+yreturn a
print(jia(6,3))#9

2.不定数目的参数

定义

1. *号代表这个参数是个不确定个数的参数
2. 多个参数要用for进行循环输出
3. 在for循环中进行累加

def add(x,*y):total = xfor i in y:

累加

def add(x,*y):total =xfor i in y:total += ireturn total
print(add(1,2,3,4,5,6,7,8,9))#45
print(add(1,2))#3

返回值

返回值只能是一个吗，可以是多个吗
可以返回多个值，多个值之间用逗号隔开

定义调用

 def suanfa(x,y):sum01 =x+ycheng01 =x*ychu01 =x/yreturn sum01,cheng01,chu01
print(suanfa(10,5))#(15, 50, 2.0)

Python数据类型函数相关推荐

1. python datatype函数_python 数据类型 datatype

   python 数据类型 datatype 列表list 元组tuple 集合set 字典dictionary 字符串string 一.列表list list :python的一种数据类型.是可变的,有 ...

2. python中函数包括标准库函数吗_Python语言和标准库（第二章：函数）

   a-如何创建函数. b-给出一些指导原则,帮助思考如何创建和组织程序以使用函数. c-如何编写函数,使随后可以询问它们的工作方式和实现的功能. 2.1将程序放在单独的文件里 为了更加方便,从现在开始, ...

3. exit函数_全面深入了解 Python 魔法函数

   (点击上方公众号,可快速关注一起学Python) 作者:浪子燕青       链接: http://www.langzi.fun/Python魔法函数.html 魔法函数概念 魔法函数是以双下划线开头 ...

4. python eval 入门_Python学习笔记整理3之输入输出、python eval函数

   Python学习笔记整理3之输入输出.python eval函数 来源:中文源码网    浏览: 次    日期:2018年9月2日 Python学习笔记整理3之输入输出.python eval函数 ...

5. python所有函数用法_python函数用法总结

   空函数 如果想定义一个什么事也不做的空函数,可以用pass语句: def nop(): pass pass语句什么都不做,那有什么用?实际上pass可以用来作为占位符,比如现在还没想好怎么写函数的代码 ...

6. python数据类型-Python语言基本数据类型

   本文主要向大家介绍了Python语言基本数据类型,通过具体的内容向大家展示,希望对大家学习Python语言有所帮助. python标准数据类型 有六个标准的数据类型: 1.Number(数字) 2.S ...

7. Python 数据类型及其用法

   本文总结一下Python中用到的各种数据类型,以及如何使用可以使得我们的代码变得简洁. 基本结构 我们首先要看的是几乎任何语言都具有的数据类型,包括字符串.整型.浮点型以及布尔类型.这些基本数据类型组 ...

8. CrazyWing：Python自动化运维开发实战 九、Python数据类型之列表

   导语 序列: 序列是Python中最基本的数据结构.序列中的每个元素都分配一个数字 - 它的位置,或索引,第一个索引是0,第二个索引是1,依此类推,Python已经内置确定序列的长度以及确定最大和最小 ...

9. python dump函数_python 处理 json 四个函数dumps、loads、dump、load的区别

   1 .json.dumps() 函数是将一个 Python 数据类型列表(可以理解为字典)进行json格式的编码(转换成字符串,用于传播) eg, dict = {"age": & ...

10. python type函数

    阿里云大学人工智能学前小测验-Python测试 4.代码 print(type([1,2])) 输出结果为 A. <class 'list'> B. <class 'tuple'&g ...

最新文章

1. php人气代码,php – 人气算法
2. 开源吞噬世界，得开发者得天下
3. java实现给选中文字添加样式,天坑之路：用js给选中文字添加样式
4. wxWidgets：实现框架构造器
5. redis 原码安装
6. MSN8.0经常出现连接错误，如何解决?
7. 全宇宙首本 VS Code 中文书，来了！
8. 也谈跨域数据交互解决方案
9. 种子接近,随机数也接近吗_接近代码，接近爸爸
10. C++模板类与Java泛型类
11. VC 2008 Express 编译OpenCV2.0/2.1
12. （28）FPGA面试技能提升篇（SATA接口）
13. 鸿蒙内部测试情况,鸿蒙OS内测曝光，安卓劲敌浮出水面！
14. 计算机屏幕总闪烁,教你如何解决电脑屏幕闪烁
15. 打印一种拓扑排序(假定给的是有向无环图时）DFS+栈
16. windows下安装ubuntu16.04双系统的注意事项
17. eclipse配置java环境变量_eclipse配置环境变量
18. 爬取cloudmusic歌单
19. 对未来国产操作系统的期望
20. mina框架CumulativeProtocolDecoder.doDecode方法浅析

热门文章

1. aws lambda_AWS Lambda和Node JS的路由管理框架
2. 1415-2团队博客汇总表
3. 计算机桌面计划,电脑桌面日程安排软件
4. 搭建一个misskey实例
5. 显示隐藏文件夹，Mac显示.m2文件夹
6. flutter floor数据库框架使用
7. jdk重复安装，Error：Registry key ‘Software\JavaSoft\Java Runtime Environment\CurrentVersion（已解决）
8. 如何通过github实现个人网页上传
9. Win11 mscorsvw程序大量占用内存的解决方法
10. 安知我不知死之乐”的意境