python基础

   #1变量与标识符

##（1）变量：程序中用于保存和表示数据的占位符号

命名规则: 大小写字母、数字、下划线等字符及组合 。

变量命名方式

普通变量：全小写字母，单词之间用下划线分割，如my_python；

全局常量：全大写字母，单词之间用下划线分割，如MY_CONST；

类名：首字母大写，单词直接连在一起，采用驼峰命名法，如MyClass；

普通函数：与普通变量一样，如my_function()；

模块名：全小写字母，不使用下划线。

##(2）在 Python 里，标识符由字母、数字、下划线组成。

在 Python 中，所有标识符可以包括英文、数字以及下划线(_)，但不能以数字开头。

Python 中的标识符是区分大小写的。

以下划线开头的标识符是有特殊意义的。以单下划线开头 _foo 的代表不能直接访问的类属性，需通过类提供的接口进行访问，不能用 from xxx import * 而导入。

以双下划线开头的 __foo 代表类的私有成员，以双下划线开头和结尾的 __foo__ 代表 Python 里特殊方法专用的标识，如 __init__() 代表类的构造函数。

##Python 保留字符

下面的列表显示了在Python中的保留字。这些保留字不能用作常数或变数，或任何其他标识符名称。

Python语言有33个保留字(也叫关键字)

and	elif	iport	raise	global	as	else
in	return	nonlocal	assert	except	is	try
True	break	finally	lambda	while	False	class
for	not	with	None	continue	from	or
yield	def	if	pass	del

#2、行和缩进

学习 Python 与其他语言最大的区别就是，Python 的代码块不使用大括号 {} 来控制类，函数以及其他逻辑判断。python 最具特色的就是用缩进来写模块。

缩进的空白数量是可变的，但是所有代码块语句必须包含相同的缩进空白数量，这个必须严格执行。

##以下实例缩进为四个空格:

if True:
    print("身体康泰")
else:
    print("牛气冲天")

##错误写法

if True:
    print("身体康泰")
else:
print("牛气冲天")

3、多行语句：

##Python语句中一般以新行作为语句的结束符。

但是我们可以使用斜杠（ \）将一行的语句分为多行显示，如下所示：

one=5
two=6
three=7
total = one + \
        two + \
        three
print(total)

语句中包含 [], {} 或 () 括号就不需要使用多行连接符。如下实例：

days = ['Monday', 'Tuesday', 'Wednesday',
        'Thursday', 'Friday']

4、Python 引号

Python 可以使用引号( ' )、双引号( " )、三引号( ''' 或 """ ) 来表示字符串，引号的开始与结束必须是相同类型的。

其中三引号可以由多行组成，编写多行文本的快捷语法，常用于文档字符串，在文件的特定地点，被当做注释。

word = 'word'
sentence = "这是一个句子。"
paragraph = """这是一个段落。
包含了多个语句"""
print(word)
print(sentence)
print(paragraph)
'''范围外各三个单引号是注释'''

6、Python注释·（快速注释，选中后Ctrl+k+c）(取消注释，选中后Ctrl+k+u)

python中单行注释采用 # 开头。

#word = 'word'
#sentence = "这是一个句子。"
#paragraph = """这是一个段落。
#包含了多个语句"""
#print(word)
#print(sentence)
#print(paragraph)
'''范围外各三个单引号是注释'''

7、Python空行

函数之间或类的方法之间用空行分隔，表示一段新的代码的开始。类和函数入口之间也用一行空行分隔，以突出函数入口的开始。

空行与代码缩进不同，空行并不是Python语法的一部分。书写时不插入空行，Python解释器运行也不会出错。但是空行的作用在于分隔两段不同功能或含义的代码，便于日后代码的维护或重构。

记住：空行也是程序代码的一部分。

##开发工具：【Visual Studio 2019】

##8、什么是运算符？ 举个简单的例子 4 +5 = 9 。 例子中，4 和 5 被称为操作数，"+" 称为运算符。

Python语言支持以下类型的运算符:

• 算术运算符
• 比较（关系）运算符
• 赋值运算符
• 逻辑运算符
• 位运算符
• 成员运算符
• 身份运算符
• 运算符优先级 

接下来让我们一个个来学习Python的运算符

##（1）Python算术运算符

以下假设变量： a=10，b=20：

运算符	描述	实例
+	加 - 两个对象相加	a + b 输出结果 30
-	减 - 得到负数或是一个数减去另一个数	a - b 输出结果 -10
*	乘 - 两个数相乘或是返回一个被重复若干次的字符串	a * b 输出结果 200
/	除 - x除以y	b / a 输出结果 2
%	取模 - 返回除法的余数	b % a 输出结果 0
**	幂 - 返回x的y次幂	a**b 为10的20次方， 输出结果 100000000000000000000
//	取整除 - 返回商的整数部分（向下取整）	a=9//2 4 b=-9//2 -5

以下实例演示了Python所有算术运算符的操作：

a = 21;b = 10;c = 0;c = a + b;
print ("1 - c 的值为：", c)
c = a - b
print ("2 - c 的值为：", c)
c = a * b
print ("3 - c 的值为：", c)
c = a / b
print ("4 - c 的值为：", c)
c = a % b
print ("5 - c 的值为：", c)
# 修改变量 a 、b 、c
a = 2
b = 3
c = a**b 
print ("6 - c 的值为：", c)
a = 10
b = 5
c = a//b 
print ("7 - c 的值为：", c)

##（2）、Python比较运算符

以下假设变量a为10，变量b为20：

运算符	描述	实例
==	等于 - 比较对象是否相等	(a == b) 返回 False。
!=	不等于 - 比较两个对象是否不相等	(a != b) 返回 true.
<>	不等于 - 比较两个对象是否不相等。python3 已废弃。	(a <> b) 返回 true。这个运算符类似 != 。
>	大于 - 返回x是否大于y	(a > b) 返回 False。
<	小于 - 返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。	(a < b) 返回 true。
>=	大于等于 - 返回x是否大于等于y。	(a >= b) 返回 False。
<=	小于等于 - 返回x是否小于等于y。	(a <= b) 返回 true。

以下实例演示了Python所有比较运算符的操作：

a = 21;b = 10;c = 0
 
if  a == b :
   print ("1 - a 等于 b")
else:
   print ("1 - a 不等于 b")
 
if  a != b :
   print ("2 - a 不等于 b")
else:
   print ("2 - a 等于 b")
 
if  a > b :
   print ("3 - a 大于 b")
else:
   print ("3 - a 小于等于 b")
 
if  a < b :
   print ("4 - a 小于 b") 
else:
   print ("4 - a 大于等于 b")
 
# 修改变量 a 和 b 的值
a = 5
b = 20
if  a <= b :
   print ("6 - a 小于等于 b")
else:
   print ("6 - a 大于  b")
 
if  b >= a :
   print ("7 - b 大于等于 a")
else:
   print ("7 - b 小于 a")

##（3）、Python赋值运算符

以下假设变量a为10，变量b为20：

运算符	描述	实例
=	简单的赋值运算符	c = a + b 将 a + b 的运算结果赋值为 c
+=	加法赋值运算符	c += a 等效于 c = c + a
-=	减法赋值运算符	c -= a 等效于 c = c - a
*=	乘法赋值运算符	c *= a 等效于 c = c * a
/=	除法赋值运算符	c /= a 等效于 c = c / a
%=	取模赋值运算符	c %= a 等效于 c = c % a
**=	幂赋值运算符	c **= a 等效于 c = c ** a
//=	取整除赋值运算符	c //= a 等效于 c = c // a

以下实例演示了Python所有赋值运算符的操作：

a = 21
b = 10
c = 0
 
c = a + b
print ("1 - c 的值为：", c)
 
c += a
print ("2 - c 的值为：", c) 
 
c *= a
print ("3 - c 的值为：", c) 
 
c /= a 
print ("4 - c 的值为：", c) 
 
c = 2
c %= a
print ("5 - c 的值为：", c)
 
c **= a
print ("6 - c 的值为：", c)
 
c //= a
print ("7 - c 的值为：", c)

(4)、Python逻辑运算符：

Python语言支持逻辑运算符，以下假设变量 a 为 10, b为 20:

运算符	逻辑表达式	描述	实例
and	x and y	布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。	(a and b) 返回 20。
or	x or y	布尔"或" - 如果 x 是非 0，它返回 x 的值，否则它返回 y 的计算值。	(a or b) 返回 10。
not	not x	布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。	not(a and b) 返回 False

以上实例输出结果：

a = 10
b = 20
if  a and b :
   print ("1 - 变量 a 和 b 都为 true")
else:
   print ("1 - 变量 a 和 b 有一个不为 true")
if  a or b :
   print ("2 - 变量 a 和 b 都为 true，或其中一个变量为 true")
else:
   print ("2 - 变量 a 和 b 都不为 true")
# 修改变量 a 的值
a = 0
if  a and b :
   print ("3 - 变量 a 和 b 都为 true")
else:
   print ("3 - 变量 a 和 b 有一个不为 true")
if  a or b :
   print ("4 - 变量 a 和 b 都为 true，或其中一个变量为 true")
else:
   print ("4 - 变量 a 和 b 都不为 true")
 
if not( a and b ):
   print ("5 - 变量 a 和 b 都为 false，或其中一个变量为 false")
else:
   print ("5 - 变量 a 和 b 都为 true")

(5)Python成员运算符：

除了以上的一些运算符之外，Python还支持成员运算符，测试实例中包含了一系列的成员，包括字符串，列表或元组。

运算符	描述	实例
in	如果在指定的序列中找到值返回 True，否则返回 False。	x 在 y 序列中 , 如果 x 在 y 序列中返回 True。
not in	如果在指定的序列中没有找到值返回 True，否则返回 False。	x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。

以下实例演示了Python所有成员运算符的操作：

a = 10
b = 20
list = [1, 2, 3, 4, 5 ];
 
if ( a in list ):
   print ("1 - 变量 a 在给定的列表中 list 中")
else:
   print ("1 - 变量 a 不在给定的列表中 list 中")
 
if ( b not in list ):
   print ("2 - 变量 b 不在给定的列表中 list 中")
else:
   print ("2 - 变量 b 在给定的列表中 list 中")
 
# 修改变量 a 的值
a = 2
if ( a in list ):
   print ("3 - 变量 a 在给定的列表中 list 中")
else:
   print ("3 - 变量 a 不在给定的列表中 list 中")

(6)、Python身份运算符：

身份运算符用于比较两个对象的存储单元

运算符	描述	实例
is	is 是判断两个标识符是不是引用自一个对象	x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False
is not	is not 是判断两个标识符是不是引用自不同对象	x is not y ， 类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True，否则返回 False。

注： id() 函数用于获取对象内存地址，就像java中的hashcode()函数。

以下实例演示了Python所有身份运算符的操作：

a = 20
b = 20
 
if ( a is b ):
   print "1 - a 和 b 有相同的标识"
else:
   print "1 - a 和 b 没有相同的标识"
 
if ( a is not b ):
   print "2 - a 和 b 没有相同的标识"
else:
   print "2 - a 和 b 有相同的标识"
 
# 修改变量 b 的值
b = 30
if ( a is b ):
   print "3 - a 和 b 有相同的标识"
else:
   print "3 - a 和 b 没有相同的标识"
 
if ( a is not b ):
   print "4 - a 和 b 没有相同的标识"
else:
   print "4 - a 和 b 有相同的标识"

(7)、is 与 == 区别：

is 用于判断两个变量引用对象是否为同一个(同一块内存空间)， == 用于判断引用变量的值是否相等。

a = [1, 2, 3]
b = a
print(b is a )
 
print(b == a)
 
b = a[:]
print(b is a )
 
print(b == a)

(8)、Python运算符优先级：

以下表格列出了从最高到最低优先级的所有运算符：

运算符	描述
**	指数 (最高优先级)
~ + -	按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)
* / % //	乘，除，取模和取整除
+ -	加法减法
>> <<	右移，左移运算符
&	位 'AND'
^ |	位运算符
<= < > >=	比较运算符
<> == !=	等于运算符
= %= /= //= -= += *= **=	赋值运算符
is is not	身份运算符
in not in	成员运算符
not and or	逻辑运算符

##数据结构

List

概念

列表是序列类型的一种扩展，十分常用

• 列表是一种序列类型，创建后可以随意被修改

创建

• 使用方括号 [] 或list() 创建，元素间用逗号 , 分隔
• 列表中各元素类型可以不同，无长度限制

•	list01 = [1,2,3,4]
•	"""
•	  [] 空列表
•	  list() 里面什么都没有，创建空列表
•	  list(["张三","李四"])
•	"""
•	list02 = list() #[]
•	list03 = list(["张三","李四"])
•	print(list01)
•	print(list02)
•	print(list03)
•	list04 = [12.3,10,3.14e2,"张三"]

##常用函数

min	min(列表) 最小值
max	max(列表) 最大值
len	len(列表) 统计列表中元素的个数
sum	sum(列表) 求和

##增

 

list01 = ["赵丽颖","迪丽热巴","黄明昊","白鹿","彭于晏"]

#list.insert(index,值)  根据下标进行插入数据
list01.insert(1,"杨幂")
print(list01)  #['赵丽颖', '杨幂', '迪丽热巴', '黄明昊', '白鹿', '彭于晏']

#list.append(值) 在末尾插入
list01.append("2")
print(list01) # ['赵丽颖', '杨幂', '迪丽热巴', '黄明昊', '白鹿', '彭于晏', '2']

 ##删

list01 = ["赵丽颖","迪丽热巴","黄明昊","2","白鹿","彭于晏","赵丽颖"]

#list.pop(index) 删除指定位置的数据
list01.pop(3)
print(list01)  #['赵丽颖', '迪丽热巴', '黄明昊', '白鹿', '彭于晏', '赵丽颖']

#list.remove(值) 删除值，但是他删除的是值第一次出现的位置
list01.remove("赵丽颖")
print(list01) #['迪丽热巴', '黄明昊', '白鹿', '彭于晏', '赵丽颖']

#list.clear() 删除所有数据
list01.clear()
print(list01) #[]

##改

• List[i] = 值（要修改的值)                               

#重新进行赋值
list01[3] = "杨幂"
print(list01)  #['赵丽颖', '迪丽热巴', '黄明昊', '杨幂', '白鹿', '彭于晏', '赵丽颖']

##查

#创建list
list01 = [1,2,5,7,-2,-9]

#查询所有 ---直接打印列表名字
print(list01)
"""
  查询单个值
   利用[index]进行查询 index-->从0开始
"""
print(list01[1])  #2
"""
 查询多个值
   [start:stop]   左开右闭
   小数在前面
   正向递增  反向递减   一负一正

   
   -6 -5 -4 -3  -2  -1
   [1  2  5  7  -2  -9]
    0  1  2  3   4   5
"""
print(list01[1:4])  #[2, 5, 7]
print(list01[-5:-2]) #[2, 5, 7]
print(list01[-5:4]) #[2, 5, 7]

 常用方法   

#list.reverse()   反转
list01 = [1,2,3,4,5,6]
list01.reverse()
print(list01)  #[6, 5, 4, 3, 2, 1]

#list.copy() 拷贝
list02 = list01.copy()
print(list02)

"""
 list.sort(reverse = Ture/False) 排序 默认是升序
 reverse = Ture降序  reverse = False 升序
"""
list03 = [1,8,4,2,-9]
list03.sort()
print(list03) #[-9, 1, 2, 4, 8]
list03.sort(reverse=True)
print(list03)  #[8, 4, 2, 1, -9]

##元组

概念

元组是序列类型的一种扩展

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

创建

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

创建
•	tuple01 = (1,2,3)
•	tuple02 = tuple() #空元组  ()
•	tuple03 = tuple((5,6,7))
•	print(tuple01)
•	print(tuple02)
•	print(tuple03)
意义
•	#创建
•	tuple02 = tuple() #空元组  ()
•	list01 = list() #[]

空列表  空元组  空集合 空字典都是False
•	 all()
•	"""
•	print(all([[],()])) #False

##查

#创建
tuple02 = (1,2,3,4,5,6)
"""
 查询所有值  直接打印元组名字
 查询单个值  [index]
 查询多个值  [start:stop] 左开右闭 一负一正 
 -6  -5  -4  -3  -2  -1
 (1,  2,  3,  4,  5,  6)
  0    1   2  3   4   5
"""
print(tuple02)
print(tuple02[2])
print(tuple02[1:4])
print(tuple02[-5:-2])
print(tuple02[-5:4])

##运算符

#创建
Str = ("张三")
print(type(Str)) #
#字符串只能存放一个值  元组可以存放多个值，加个逗号可以进行区分
tuple01 = ("张三",)
print(type(tuple01)) #
#复制完以后把数据变成元组
print(tuple01*3)  #('张三', '张三', '张三')

##字典 

存在一种映射关系

• 映射是一种键(索引)和值(数据)的对应

key	value
张三	18

##创建

• 键值对：键是数据索引的扩展
• 字典是键值对的集合，键值对之间无序(没有索引）
• 采用大括号{}和dict()创建，键值对用冒号: 表示
• 字典类型是“映射”的体现
• <字典变量> = {<键1>:<值1>, … , <键n>:<值n>}

增

  dict01[新的key] = 新的值  添加数据

dict01["小乔"] = "天魔缭乱"

print(dict01) #{'鲁班': '空中支援', '花木兰': '切换形态', '孙策': '开船', '元哥': '无敌时间移位', '小乔': '天魔缭乱'}

删

 dict.pop(key)  根据key删除一对数据

 dict.clear()  清除所有数据

dict01.pop("元哥")

print(dict01) #{'鲁班': '空中支援', '花木兰': '切换形态', '孙策': '开船'}

 改

只能修改值，不可以修改key

  为什么：因为key是唯一的，不能重复的，避免出现重复的情况所以不能修改

  怎么修改：先根据key拿到值  dict01["孙策"]再重新赋值

dict01["孙策"] = "乘风破浪"

print(dict01) #{'鲁班': '空中支援', '花木兰': '切换形态', '孙策': '乘风破浪', '元哥': '无敌时间移位'}

 查

dict.keys()  查看所有的key

dict.values()  查看所有的values

查询单个值

  1.dict[key]  利用key查询value

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

o={1:2,2:1,3:7}
o[1]=2

查询所有值(包括key和value)

  1.直接打印字典名

  2.dict.items() 迭代方法

print(dict01) #{'鲁班': '空中支援', '花木兰': '切换形态', '孙策': '开船', '元哥': '无敌时间移位'}

print(dict01.items()) #dict_items([('鲁班', '空中支援'), ('花木兰', '切换形态'), ('孙策', '开船'), ('元哥', '无敌时间移位')])

##常用的函数和方法

 

dict01 = {"张三":20,"王五":30,"赵六":70,"李四":80}
dict02 = {"翠花":20,"光头强":10}
dict01.update(dict02)
print(dict01) #{'张三': 20, '王五': 30, '赵六': 70, '李四': 80, '翠花': 20, '光头强': 10}
print(dict02) #{'翠花': 20, '光头强': 10}

dict01 = {"张三":20,"王五":30,"赵六":70,"李四":80}
dict02 = {"翠花":20,"光头强":10}

"""
  del 字典名[key]  删除指定位置的数据
  和pop一样 
  dict.pop(key) 删除指定位置的数据
"""
del dict01["李四"]
print(dict01) #{'张三': 20, '王五': 30, '赵六': 70}

##集合

概念set

集合是多个元素的无序(没有下标)组合

集合类型与数学中的集合概念一致

集合元素之间无序，每个元素唯一，不存在相同元素

集合元素不可更改，不能是可变数据类型   

为什么？ 无序唯一

数据重复，会自动去重

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

  •	set01 = {1,2,3,4,5}
  •	set02 = set() #set()
  •	set03 = set({9,10,11})
  •	print(set01)
  •	print(set02) 
  •	print(set03)
  •	"""
  

  ##增

• 

set01 = {"花木兰","貂蝉","妲己","王昭君"}

"""
  set.add(数据) 添加一个数据  也能添加已有的数据，
虽然不报错，但是不显示
"""
set01.add("杨玉环")
print(set01) #{'花木兰', '王昭君', '貂蝉', '妲己', '杨玉环'}
set01.add("花木兰")
print(set01) #{'花木兰', '杨玉环', '王昭君', '妲己', '貂蝉'}

"""
 set01.update(set02) 批量添加数据
   把set02添加到zet01中
"""
set02 = {"嬴政","武则天"}
set01.update(set02)
print(set01) #{'花木兰', '嬴政', '杨玉环', '妲己', '王昭君', '武则天', '貂蝉'}

 ##删

set01 = {"喜羊羊","美羊羊","懒洋洋","沸羊羊","暖羊羊","慢羊羊","灰太狼"}

"""
  set.discard(值)  删除集合中的值 
    如果数据不存在，不报错
""" 
set01.discard("美羊羊")
print(set01) #{'慢羊羊', '喜羊羊', '灰太狼', '暖羊羊', '懒洋洋', '沸羊羊'}
set01.discard("小灰灰")
print(set01)

"""
 set.remove(值) 删除集合中的值 
   KeyError: '小灰灰'
   如果没有这个值，会报错
"""
set01.remove("慢羊羊")
print(set01) #{'懒洋洋', '灰太狼', '沸羊羊', '喜羊羊', '暖羊羊'}
#set01.remove("小灰灰")
#print(set01)

"""
 set.pop() 随机删除
"""
set01.pop()   #{'懒洋洋', '沸羊羊', '喜羊羊', '暖羊羊'}
              #{'灰太狼', '喜羊羊', '沸羊羊', '暖羊羊'}
print(set01)

# set.clear() 清空

##查

直接打印集合名字去查询

不能使用索引进行查询，因为我们集合是无序的

print(set01)

##集合常用函数和方法

set01 = {"喜羊羊","美羊羊","懒洋洋","沸羊羊","暖羊羊","慢羊羊","灰太狼"}

#set.copy() 复制/拷贝一个一模一样的集合
set02 = set01.copy()
print(set02) #{'慢羊羊', '美羊羊', '灰太狼', '喜羊羊', '沸羊羊', '暖羊羊', '懒洋洋'}

#len(set) 返回集合的元素个数，集合的长度
a = len(set01)
print(a) #7

"""
 x in set 元素x在不在集合当中
 x not in set 元素不在集合中
"""
print("慢羊羊" in set01) #True
print("慢羊羊" not in set01) #False

#set(x) 把其他数据类型（x）转换成集合类型 
Str = "hello"
print(Str) #hello
print(type(Str))

b = set(Str)
print(type(b)) #
print(b) #{'o', 'e', 'h', 'l'}

 ##交差并补

交集：          （ & 或者 intersection ）

并集： 　　  （ | 或者 union ）

差集：  　　 （ -  或者  difference ）

补集：  　 （  ^  或者 symmetric_difference）

子集与超集：（  返回 true 或者 false）

 ##增强符

 set01 |= set02  并等   set01 = set01 | set02

 ##总结一下 

1.字符串
字符串是不可变的序列

2.列表
列表是可变的，可以通过索引赋值，改变列表中的元素

3.元组
元组是不可变的序列

4.字典

字典是一种可变的类型，可以存储任意类型的数据，字典中的键不能重复，并且只能用不可变的类型作为字典的键

元组：查   列表：增删改查   字典：增删改查   集合：增删查

 ##为什么内存地址不一致

基本数据类型会为每一个对象单独赋值，即使值是一样,也是不同的内存

为什么vs内存一样，idle内存却不一样

   在vs是一起创建的，在idle中是先创建一个，在创建另外一个‘

##序列类型

下面这段代码可以解释

>>> list01 = [1,2,3,4]
>>> list02 = list01
>>> id(list01)
2785429714632
>>> id(list02)
2785429714632
>>> list02 = ["张三","李四"]
>>> id(list01)
2785429714632
>>> id(list02)
2785422912456

##函数 

##编程语言的函数都可以分为两类：内置函数和自定义函数。

##内置函数分为  数字相关的内置函数  序列相关的内置函数  类型相关的内置函数

# abs(x) 求绝对值
print(abs(-10))  #10
 
"""
  divmod(x,y)  (x//y)商和(x%y)余数，同时输出商和余数
   x//y  整除  向下取整
   x%y  余数=被除数-除数*商  10%-3=-2
"""
x = 10
y = 3
print(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,5,10)) #2**5 = 32  32%10=2

 

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

print(round(3.1415926,4))  #3.1416

#max(x1,x2,..........,xn) 返回最大值

print(max(4,6,9,1,0,10)) #10

 int(x) 将x转换成整数，舍弃小数部分
   可以把字符串转成整数,但是你的字符串必须是数字字符串 比如"123"
"""
print(int(3.92)) #3
print(int("123")) #123
#print(int("hello"))

"""
 float(x) 将x转换成小数，增加小数部分
   可以把字符串变成小数,但是字符串必须是数字字符串 比如"123" "22.9"
"""
print(float(12)) #12.0
print(float("22")) #22.0
#print(float("hello"))
"""
 complex(x) 将x变成复数，增加虚数部分
   x可以是整数 、小数、数字类型的字符串
"""
print(complex(10)) #(10+0j)
print(complex(3.14)) #(3.14+0j)
print(complex("4.56")) #(4.56+0j)
#complex("hello")

 ##进制的转换：bin()，oct()和hex()函数

 bin() 转换成二进制(0b) 返回一个字符串

 oct() 转换成八进制(0o)  返回一个字符串

 hex() 转换成十六进制(0x) 返回一个字符串

a = bin(100)
print(a) #0b1100100
print(type(a)) #

ASCII码与字符的转换：∞

chr(x) 把十进制转换成ASCLL编码字符

 ord(x) 把ASCLL编码字符转换成十进制

##序列相关的内置函数

all(序列)  all()接受一个序列 
    当序列中所有的元素都计算为真时，返回True，否则为False

  []  ()  {}  set()都是Flase
All(“张三”,12.5,3e10,())
"""
a = ["hello",3.14,4+3j,{"张三":18,"李四":20}]
print(all(a)) #True
b = ["hello",3.14,4+3j,{"张三":18,"李四":20},[]]
print(all(b)) #False

"""
 any(x)  any()则在序列中的任意一个元素为真时返回True，否则为False
Any(“张三”,[],(),{})

"""
c = [{},(),set()]
print(any(c)) #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) 升序排序 返回一个新的序列

a = [1,7,3,5,8,2]

print(sorted(a)) #[1, 2, 3, 5, 7, 8]

 reversed(x) 反序排序 返回迭代器

b = reversed(a)

,print(list(b)) #[8,7,5,3,2,1]

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

print(reversed(c)) #

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]

##enumerate(x)   可以迭代序号和值：返回一个迭代对象

  #enumerate(x)  输出序号（下标）和值 返回值是一个枚举对象，利用for循环输出#

a = enumerate(['a','b','c','d','e'])
print(a) #
for xiabiao,zhi in a:
    print(xiabiao,zhi)
"""
0 a
1 b
2 c
3 d
4 e

##类型相关的内置函数

 int(x) 将x转换成整数，舍弃小数部分
   可以把字符串转成整数,但是你的字符串必须是数字字符串 比如"123"
"""
print(int(3.92)) #3
print(int("123")) #123
#print(int("hello"))

"""
 float(x) 将x转换成小数，增加小数部分
   可以把字符串变成小数,但是字符串必须是数字字符串 比如"123" "22.9"
"""
print(float(12)) #12.0
print(float("22")) #22.0
#print(float("hello"))
"""
 complex(x) 将x变成复数，增加虚数部分
   x可以是整数 、小数、数字类型的字符串
"""
print(complex(10)) #(10+0j)
print(complex(3.14)) #(3.14+0j)
print(complex("4.56")) #(4.56+0j)
#complex("hello")



"""
   isinstance(变量,类型)  类型判断,如果变量和类型一致是true，不一致是false
     变量：自定义变量
     类型：Str int float list stuple dict set
     [1,2,3,4] --list列表
     {"张三":18,"李四":20}----dict字典
     {1,2,3} ---set集合
     (1,2) --tuple元组
"""
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+y

      return sum01

>>> add(2,3)

5

##参数

  参数可以是0个，也可以是多个

##带默认值的参数

Y的默认值是10

 >>> def cheng(x,y=10):

     c = x*y

     return c

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

 >>> cheng(2)

20

>>> cheng(2,5)

10

 ##不定数目的参数

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

def add(x,*y):
	total = x
	for i in y: 
     #累加
		total += i
	return total

 返回值也可以是多个值，多个值之间用逗号隔开

def suanfa(x,y):
	sum01 = x+y
	cheng01 = x*y
	jian01 = x-y
	return sum01,cheng01,jian01

 ##模块

import 模块名1,模块2  as 别名

     导入整个模块，包括模块里面的属性、变量、方法、函数

自定义模块

1. 一个python文件就是一个模块
2.  导入的时候，直接import  文件名

   ---

   import count as c

   #打印出5

   print(c.add(3,5)) #8