Python基础学习（2）基本数据类型、三元运算、深浅拷贝、函数式编程、参数、变量、lambda表达式、python内置函数、文件处理、上下文管理、递归、命名空间、闭包
1. 基本数据类型
1）数字
（1）int类型
常用功能：
.__add__()
bit_length()获取可表示的二进制的最短位数
2）字符串，str类型，一次性创建，不能被修改，只要修改就需要再创建
常用方法：
a = 'bob'
（1）capitalize()，首字母大写
a.capitalize
（2）center，居中显示，第一个参数为位数，第二个参数为填充符号（默认为空格）
a.center(20,'*')
（3）count，字符串中某字符出现的次数，第一个参数指定查找的字符，第二个参数为查找起始位置，第三个参数为查找的终止位置
a.count('b',0,3)
（4）endswith，是否以某结尾，第一个参数指定查找的字符，第二个参数为查找起始位置，第三个参数为查找的终止位置
a.endswith('b')
（5）expandtabs，将tab转化成空格
a = 'hello\t999'
a.expandtabs()
（6）find，寻找子序列位置，如果没找到，返回-1
a.find('lo')
（7）format，字符串格式化，动态参数
"hello {0}, age {1}".format('Bob',19)
（8）index，子序列位置，如果没找到，报错
a = 'hello world'
a.index('w')
（9）isalnum，判断是否是字母和数字
a.isalnum('Abc')
（10）isalpha，判断是否是字母
a.isalpha()
（11）isdigit，判断是否是数字
a.isdigit()
（12）islower，判断是否小写
a.islower()
（13）isspace，判断是否空格
（14）isupper，判断是否大写
（15）istitle，判断是否标题
（16）join，连结
name_list=['Alex','Eric']
s = ' '.join(name_list)
（17）ljust，内容左对齐，右侧填充
（18）lower，变小写
（19）lstrip，移除左侧空白
（20）rstrip，移除右侧空白
（21）replace，替换
a.replace('a','El')
（22）rfind，从右向左找
（23）rindex，从右向左找
（24）rjust，内容右对齐，左侧填充
（25）split，分割，第二个参数可以指定最多分割几次
a.split('e')
（26）rstrip，移除右边空白
（27）startswith，是否以某开始
（28）strip，移除两段空白
（29）swapcase，大写变小写，小写变大写
（30）title，将字符串转换成标题
（31）upper，变为大写
（32）zfill，返回指定长度的字符串，原字符串右对齐，前面填充
（33）索引
a[2]
（34）切片
a[0:2]
（35）长度，len()
（36）字符 =》字节
bytes_list = bytes("字符串",encoding='utf-8')
print(bytes_list) #默认每个字节都是16进制表示
for b in bytes_list:
print(b) # 默认每个字节都是10进制表示
10进制的数字=》2进制
bin(10进制的数字)
3）列表，list
name_list = ['Steve','Bill','John']
（1）索引
name_list[0]
（2）切片
name_list[0:2]
（3）len长度
name_list[2:len(name_list)]
（4）for循环
for i in name_list:
print(i)
（5）append追加元素
name_list.append('Jobs')
（6）count统计某个元素出现的次数
name_list.count('Jobs')
（7）extend，扩展列表
name_list.extend(temp_list)
（8）index，获取某个值的索引
name_list.index('John')
（9）insert，在某个位置插入一个值
name_list.insert(1,'Nash')
（10）pop，拿到最后一个值并赋给新值
name_list.pop()
（11）remove，移除从左找到的第一个某元素
name_list.remove('Steve')
（12）reverse，将列表反转
name_list.reverse()
（13）sort，将列表排序
name_list.sort()
（14）del，删除某个索引下的元素
del name_list[1]
4）字典，dict，每个元素都是键值对
user_info = {'name':'Steve', ‘age’:25, ‘gender’:'M'}
（1）索引
user_info['name']
（2）循环
for i in user_info:
print(i)
（3）键值对
user_info.keys()
user_info.values()
user_info.items()
for key, val in user_info.items():
print(key + ":" + val)
（4）clear，清除所有内容
user_info.clear()
（5）get，根据key获取值，如果key不存在，可以制定一个默认值
user_info.get('nation','unknown')
（6）has_key，检查字典中指定key是否存在
user_info.has_key('age')
（7）pop，获取并在字典中移除
user_info.pop('age')
（8）setdefault，如果key不存在，则创建，如果存在，则返回已存在的值且不修改
user_info.setdefault('nation','UK')
（9）update，批量更新
test = {'language':'English','phone':'13123231441'}
user_info.update(test)
（10）del，删除
del user_info('phone')
（11）enumerate，自动生成键值对形式，key默认自增，从0开始
li = [‘CPU’,'Memory','Driver','Screen']
for key,item in enumerate(li):
print(key,item)
（12）range，指定范围，生成指定的数字，还可以指定步幅
for i in range(1,10,2):
print(i)
for i in range(10,1,-2):
print(i)
（13）fromkeys，从某个字典选某些keys，并指定value，生成一个新的字典
5）集合，不允许重复，可以用来去重
s = set()
（1）add，添加元素
s.add('Steve')
（2）difference，找前A中存在的，B中不存在的元素
s1 = (11,22,33)
s2 = (22,55,33)
s1_remain = s1.difference(s2) # 留下11
s2_remain = s2.difference(s1) # 留下55
（3）difference_update，从当前集合中删除和B中相同的元素
s1 = (11,22,33)
s2 = (22,55,33)
s1_remain = s1.difference_update(s2) # 留下11
（4）clear，清空
s.clear()
（5）discard，移除指定元素，不存在不报错
s.discard()
（6）remove，移除元素
s.remove('Steve)
（7）intersection，取交集
（8）intersection_update，取交集并更新到A中
（9）isdisjoint，如果没有交集，返回True，否则返回False
（10）issubset，是否是子序列
（11）issuperset，是否是父序列
（12）pop，移除元素，并返回该元素
（13）symmetric_difference，取并集
（14）symmetric_difference_update，取并集并更新
2. 三元运算（又名三目运算）
name = 值1 if 条件 else 值2
name = 'Steve' if 1 == 1 else 'Bill'
3. 深浅拷贝，数字和字符串不管怎么拷贝都是同一份
import copy
n1 = 123
1）浅拷贝，只拷贝了外面的一层，指向你n1的内存地址空间
n2 = copy.copy(n1)
2）深拷贝，除了最后一层都拷贝
n3 = copy.deepcopy(n1)
4. 函数式编程
1）定义函数
def 函数名(形式参数):
函数体
return 值
2）return返回值
注意：函数在执行过程中只要遇到return语句，就会停止执行并返回结果；如果未在函数中指定return，那这个函数的返回值为None
例，发送邮件的函数：
def email():flag = Truetry:import smtplibfrom email.mime.text import MIMETextfrom email.utils import formataddrmsg = MIMEText('Email Message','plain','utf-8')msg['From'] = formataddr([‘Steve’,'steve@gmail.com'])msg['To'] = formataddr(['Bill','bill@yahoo.com'])msg['subject'] = 'Test Email'server = smtplib.SMTP(''smtp.126.com",25)server.login('steve@gmail.com','123456')server.sendmail('steve@gmail.com',['bill@yahoo.com',], msg.as_string())server.quit()except:flag = Falsereturn flag3）嵌套函数
def fun1():print('alex')def func2():print('eric')（1）函数内部可以再次定义函数
（2）执行需要被调用
4）匿名函数
def calc(x,y):return x * yfunc = lambda x,y: x*y # 声明一个匿名函数
print(func(3,5))print(list(map(lambda x: x*x, list(range(10)))))
特点：
（1）节省代码量
（2）看起来高大上
5）高阶函数
只要满足以下任意一个条件，即是高阶函数
（1）接受一个或多个函数作为输入
（2）return返回另外一个函数
5. 参数
1）形参，实参（默认，按照顺序）
指定形参传入实参，可以不按照顺序
2）默认参数（有默认值的参数一定要放在所有参数的尾部）
def enroll(name, age, nationality='China')
3）关键参数，指定了参数名的参数就叫关键参数，但关键参数必须放在位置参数之后
def enroll(name, age, nationality='China')
stu_1 = enroll('Alex', nationality='USA, age = 22)
4）动态参数，非固定参数
(1) *args，将参数变为元组
def f(*args):
(2)**kwargs，将参数转换为字典
def f(**kwargs):
def fun(name, *args, **kwargs)
func("Steve", "tt", "Lebron", addr="Beijing", age="24")
6. 变量，可以通过global指定某变量为全局变量
1）全局变量，定义在函数外部的一级代码。全局变量全局能用。默认全局变量全用大写
在函数里面修改全局变量：
name = 'a'
def change_name():global namename = bprint(name)
print(name)在函数里面无法修改的数据类型（不加global的话）：str，int
2）局部变量，定义在函数里的变量。只在局部生效。默认局部变量全用小写。在函数内部，可以应用全局变量。如果全局和局部都有一个变量为data，函数查找变量的顺序为从内而外。
7. lambda表达式
lam = lambda a1, a2: a1 + a2
8. Python内置函数
1）abs，绝对值
n = abs(-12300)
2）all，循环参数，如果每个元素都为真，那么all的返回值为真，有一个为假则为假
r = all([True,True,False])
False
3）bool，0、None、空值都为假，其他为真，把一个对象转换成布尔值
4）any，只有一个为真，则为真
5）ascii，对象的类中找__repr__，获取其返回值
ascii(对象)
6）bin，二进制
7）oct，八进制
8）int，十进制
9）hex，十六进制
10）二进制转换为十进制
num = int('0b11', base = 2)
11）八进制转换为十进制
num = int('0o11', base = 8)
12）十六进制转换为十进制
num = int('0xe', base = 16)
13）bytes，字节
14）bytearray，字节列表
15）字符串转换为字节
bytes("xxx", encoding="utf-8")
16）callable，查看对象是否可以执行
def func1():
return
r = callable(func1)
print r
17）compile，编译
code = '''def hellocute() return 123 '''
func = compile(code, "<string>", "exec")
18）eval，转化为数值，有返回值，只能处理单行代码
ret = eval("1 + 3")
print ret
19）exec，执行字符串形式的python代码
exec("for i in range(10): print(i)")
20）filter，循环可以迭代的对象，获取每一个参数，函数（参数）
filter(函数，可以迭代的对象)
def func1(x):
if x > 10:
return True
else:
return False
ret = filter(func1, [8, 12, 7, 66, 45, 6, 92])
for i in ret:
print i
21）map，
map(函数，可以迭代的对象)
def func(x):
return x + 1
list1 = [1,2,3,4,5]
res = map(func, list1)
22）frozenset，不可变得集合
23）globals，获取当前代码中所有全局变量
23）locals，获取所有局部变量
24）hash，生成哈希值，一般用来作字典key的优化
25）id，查看对象内存地址
26）input，输入
27）isinstance，判断是否是某个类的对象
li = [11,2]
r = isinstance(li, list)
28）max，获取列表、集合等中的最大值
29）min，获取列表、集合等中的最小值
30）pow，求指数
i = pow(2, 10)
31）round，四舍五入
n = round(3.3)
31）open，文件操作
open(文件名，模式，编码)
打开文件的模式有：
r：只读模式【默认】
w：只写模式【不可读；不存在则创建；存在则清空内容】
x：只写模式【不可读；不存在则创建，存在则报错】
a：追加模式【不可读；不存在则创建；存在则只追加内容】
“+”表示可以同时读写某个文件
r+：读写【可读，可写】
w+：写读【可读，可写】
file = open('hadoop.log')
data = file.read()
file.close()
print data
字节文件的读写，python3中的方法，以b方式打开时，读取到的内容是字节类型，写入时也需要提供字节类型
rb或r+b：只读，python内部将二进制编码转换成了字符串
file = open('hadoop.log', 'rb')
data = file.read()
file.close()
print(data)
wb或w+b：只写
file = open('hadoop.log', 'rb')
file.write(bytes("Hello World"), encoding='utf-8')
xb或x+b：
ab或a+b：
指针：
file = oepn("hadoop.log", "r+")
print(file.tell()) # file.tell() 当前指针的位置，刚打开文件指针为起始位置0，
data = file.read()
file.write("I love Python")
file.seek(0) # file.seek() 指定指针的位置
data = file.read(3) # file.read(3)指定指针的读取位置
# w，末尾追加，指针移动到最后
# w+，先清空，再写的时候，就可以读了，先清空，之后写的才能读写，指针到最后
file = open("hadoop.log", "w+", encoding="utf-8")
file.write("Steve")
file.seek(0)
data = file.read()
file.close()
print(data)
# x+如果文件存在，则报错
#a+追加内容，文件打开的同时，指针已经到最后了；写时，追加，指针也会放到最后
file = open("hadoop.log", "a+", encoding="utf-8")
data = file.read()
file.seek(0)
file.close()
file.tell() # 获取指针的位置
file.seek(num) # 调整指针的位置
32）sum，求和
33）type，查看对象类型
34）zip，将两个组合起来
li1 = [1,2,3,4]
li2 = ['a','b','c','d']
r = zip(li1, li2)
for i in r:
print i
35）sort，排序，元素必须是同一种类型
36）print
print(s, end='|', sequence='->')
37）locals，局部变量
38）
内置函数实例：生成一个随机数，65-90，数字转化正字母，chr(数字)
import random
i = random.randrange(65,91)
c = chr(i)
print c
内置函数实例：随机生成字符串
import random
temp = ""
for i in range(0,6):
num = random.randrange(4)
if num == 3 or num == 1:
rand1 = random.randrange(0,10)
temp += str(rand1)
else:
rand2 = random.randrange(65,91)
c = chr(rand2)
temp += c
print temp
9. 文件处理
f = open('data.txt', 'r', encoding='utf-8')data = f.read()f.close()1）对文件的处理模式
'r'，只读，字符。读完一遍内容后，光标会移到最后
'rb'，只读，二进制
'w', 只写，字符
'wb'，只写，二进制
'a', 追加
'r+', 读写混合
'w+', 写读混合，先创建文件，原来的文件内容先被重写
2）如果不知道文件的编码方式，chardet可以智能检测：
import chardet
result = chardet.detect(open('log', 'rb').read())
print(result)3）循环文件
f = open('data.txt', 'r')
lines = f.read()
for line in lines:print(line)4）对文件内容操作的api
（1）close，关闭文件
（2）fileno，文件描述符
（3）flush，刷新文件内部的缓冲区，把文件从内存强指刷新至硬盘
（4）read，读取指定字节数据
（5）readable，是否可读
（6）readline，仅读取一行数据
（7）seek，指定文件中指针位置
（8）seekable，指针是否可操作
（9）tell，获取指针位置
（10）truncate，截断数据，仅保留指定之前的数据
（11）write，写内容
10. 上下文管理，自动关闭文件，且可以同时打开两个文件
with open("hadoop1.log", 'r') as file1, open("hadoop2.log", "r") as file2:
pass
with open("hadoop1.log", "r") as file1, open("new_hadoop.log", "w") as file2:
pass
11. 递归
递归函数：
def factorial(n):if n == 1:return 1return n * factorial(n - 1)
print(factorial(10))
尾递归优化：
def cal(n):print(n)return cal(n + 1)
cal(1)12. 命名空间，名称空间
名称空间正是存放名字x与1绑定关系的地方
1）名称空间共3种：
（1）locals：是函数内的名称空间，包括局部变量和形参
（2）globals：全局变量，函数定义所在模块的名字空间
（3）builtins：内置模块的名字空间
不同变量的作用域不同就是由这个变量所在的命名空间决定的
2）作用域即范围
（1）全局范围：全局存活，全局有效
（2）局部范围：临时存活，局部有效
3）作用域的查找范围
locals-》enclosing function-》globals-》__builtins__
locals是函数内的名字空间，包括局部变量和形参
enclosing外部嵌套函数的名字空间
globals全局变量，函数定义所在模块的名字空间
builtins内置模块的名字空间
13. 闭包
代码示例：
def func():n = 10def func2():print("funky:", n)return func2f = func()
print(f)
f()Python基础学习（2）基本数据类型、三元运算、深浅拷贝、函数式编程、参数、变量、lambda表达式、python内置函数、文件处理、上下文管理、递归、命名空间、闭包相关推荐
- Python学习 Day8-2 python的三元表达式（三目运算符）、lambda表达式、内置函数
Python中的三元表达式(三目运算符) 语法:为真时的结果 if 判断条件 else 为假时的结果(注意,没有冒号) >>print(1 if 5 > 3 else 0) 1 Py ...
- python lambda 逻辑_Python之lambda表达式和内置函数
lambda表达式其实就是简化的函数表达式. 它只用于处理简单逻辑, 它会自动return数据 通常定义一个函数,按照以下形式:def func(arg): return arg +1 result ...
- Python之lambda表达式和内置函数
lambda表达式其实就是简化的函数表达式. 它只用于处理简单逻辑, 它会自动return数据 通常定义一个函数,按照以下形式: 1 2 3 4 5 def func(arg): ret ...
- python基础（三元运算+深浅拷贝+函数参数）
三元运算 三元运算,又称三目运算,主要作用是减少代码量,是对简单的条件语句的缩写. 1 书写格式: 2 result = 值1 if 条件 else 值2 3 即如果条件成立,则将值1赋给result ...
- python进入内置函数文件_python基础知识-set、函数、内置函数、文件操作
一.set set集合,是一个无序且不重复的元素集合 1.创建 se = {"123","456"}print(type(se)) s= set() #创建空集 ...
- python不允许使用关键字作为变量名_python函数变量_python不允许使用关键字作为变量名,允许使用内置函数名作为变量名,但这会改变函数 - 云+社区 - 腾讯云...
广告关闭 腾讯云11.11云上盛惠 ,精选热门产品助力上云,云服务器首年88元起,买的越多返的越多,最高返5000元! 每个变量在使用前都必须赋值,变量赋值以后该变量才会被创建. 在python 中, ...
- 2019-07-12 函数递归、二分法、匿名函数、三元表达式、内置函数
一.递归函数 我理解为递归函数也是函数嵌套的一种,函数在调用时,直接或间接的调用了自身. 简单的直接调用本身(这种调用会一直循环下去,会很占内存空间,所以python解释器为了防止无限占用内存,对这种 ...
- python匿名函数里用if_python匿名函数 高阶函数 内置函数 文件操作
1.匿名函数 匿名就是没有名字 def func(x,y,z=1): return x+y+z 匿名 lambda x,y,z=1:x+y+z #与函数有相同的作用域,但是匿名意味着引用计数为0,使用 ...
- python查看变量内存地址的内置函数是_查看变量内存地址的Python内置函数是____...
查看变量内存地址的Python内置函数是____ 答:id() 产妇乳汁分泌主要依赖于 答:哺乳时吸吮刺激 下列选项中,属于"路径面板"中的工具按钮的是 答:用前景色填充路径 用画 ...
- 字典添加数据_【Python基础学习】4. 数据类型之字典及其操作
知行校园汇 记录学习.分享干货.吐槽人生! 关注 相关说明 文章内容:Python数据类型之字典及其操作 作者博客:csdn.cxhit.com www.cxhit.com 1. 什么是字典 在Pyt ...
最新文章
- CentOS 7-(64位)系统下安装Anaconda（Python3.x）及pip使用
- linux内核网络协议栈--发送流程及函数（十）
- 在哪里买铁甲格斗机器人_铁甲雄心Ⅱ火了 优必选“超变铁甲”掀起闯关赢免单热潮...
- 一双耐克出厂价70元，代工老板赚到900亿身家
- Linux内核实验要注意的地方
- js获取post请求参数_SpringMVC请求参数获取时，有这六种方式值得学习
- 迅雷java_Java实现迅雷地址转成普通地址
- 3cdaemon漏洞挖掘 Exploit
- 计算机中运用的数学原理,生活中的数学原理
- react兼容safari9_react项目兼容ie浏览器配置
- 春节快过腻了？不妨关心下太空探索
- android studio 导出 aar,Android Studio 导出 .aar包的操作流程
- 我只说一次，这样用领英开发国外客户，屡试不爽！
- 开源库实现SwitchButton开关按钮
- Hadoop基础操作--查询集群的计算资源信息
- 有人用python抢到过吗_再不看就晚了，我用Python抢到了回家的火车票！
- python程序设计与算法基础江红答案_《Python程序设计与算法基础教程（第二版）》江红 余青松，第十一章课后习题答案...
- C语言函数大全-- i 开头的函数
- Qt 程序异常结束 并且crashed——解决方法 （动态链接库）
- 计算机应用程序没声音,电脑如何关闭某个应用程序的声音