目录
1、print 输出不换行
2、格式化输出字符串
3、浮点数的处理
4、进制转换和ASCII与字符间的转换
5、随机数
6、字符串截取和内置方法
6-1）字符串截取
6-2）字符串内置方法
7、元组、列表，及其遍历方式
7-1）列表常用内容
7-2）元组
7-3）几种遍历方式：
7-4）列表与元组之间的转化
8、字典即其遍历方法
8-1）字典的基本操作
8-2）字典的遍历
9、函数
9-1）默认参数
9-2）可变长参数
9-3）字典参数（关键字参数）
9-4）多种返回值
9-5）匿名函数（lambda 表达式）
10、包和模块
10-1）导入整个模块：
10-2）从模块中导入指定的内容：
10-3）从包中导入模块等：
1、print 输出不换行
''' 让第一次的输出不换行 '''
string = 'hello '
str = 'world.'
print(string, end='')
print(str, end='\n\n\n') # 结尾空两行
print('goodbye world')
2、格式化输出字符串
phone = input('请输入电话号码: ') # 命令行输入
string = 'your phone is : '
print(string + phone)
print('%s%d' % (string, int(phone)))
print(f"{string}{phone}")
print('{}{}'.format(string, phone))
3、浮点数的处理
import math
num = 123.745
print('舍去小数取整：', int(num))
print('返回两位小数：', '%.2f' % num)
print('返回两位小数：', '{:.2f}'.format(num))
print('向上取整：', math.ceil(num))
print('向下取整：', math.floor(num))
print('舍去小数取整：', math.trunc(num))
print('舍去小数取整：', int(num))
print('四舍五入取整：', round(num))
4、进制转换和ASCII与字符间的转换
ord()：字符转ASCII
chr()：ASCII转字符
bin()：十进制转二进制
oct()：十进制转八进制
hex()：十进制转十六进制
'''字符与ASCII码之间的转换'''
print(ord('A')) # 字符转ASCII码 65
print(chr(48)) # ASCII码转字符 0
'''进制转换'''
print(bin(78)) # 十进制转二进制 0b1001110
print(oct(78)) # 十进制转八进制 0o116
print(hex(78)) # 十进制转十六进制 0x4e
5、随机数
'''随机数'''
import random
r = random.randint(1, 10) # 闭区间内生成随机数
print(r)
r2 = random.randrange(1, 10, 2) # 左闭右开区间生成随机数,步长为2
print(r2)
r3 = random.uniform(1, 5) # 生成随机小数 左闭
print(r3)
r4 = random.choice("ABSCD") # 取随机的一个元素
print(r4)
r5 = random.choice([1,3,4,5,6,2])
print(r5)
6、字符串截取和内置方法
6-1）字符串截取
source = 'Hello_World'
print(source[0:5]) # 取[0,5) Hello
print(source[:5]) # 取[0,5) Hello
print(source[2]) # 取下标 l
print(source[-5:-1]) # 取倒数第5到倒数第2个字符 Worl
print(source[5:]) # 第5个到最后一个字符 _World
print(source[-1]) # 取最后一个字符 d
print(source[0:5:2]) # 从范围[0,5)中取，设置步长为2，取下标为 0 2 4拼接 Hlo
6-2）字符串内置方法
source = 'HelloWorld'
print(source.count('l')) # 字符 l 在字符串中出现的次数
print(len(source)) # 字符串的长度
print(source.split('o')) # 按照o来拆分 ['Hell', 'W', 'rld']
list = ['zhang','hou','wu','wang']
print('#'.join(list)) # 数组合并成字符串 zhang#hou#wu#wang
# 编码和解码
source = '你好啊我是张三'
target = source.encode() # 将字符串按照指定的编码格式转换成字节类型,默认编码格式为utf-8
print(target, target == source) # b'HelloWorld' False
print(target.decode() == source) # True
# utf-8编码每 3个字节表示一个中文，而 gbk每 2个字节表示一个中文
source = '\n\t hello world \n\n'
print(source.strip()) # 将字符串左右的换行符和空格都清理掉
7、元组、列表，及其遍历方式
7-1）列表常用内容
.append(x)：往列表最后添加一个元素；
.pop()：移除第一个元素；
.reverse()：翻转列表；
.remove(x)：从列表中移除指定的元素；
（以上四个方法都会改变原数组）
.count(x)：统计x在列表中出现的次数；
.index(x)：x再列表中第一次出现的位置
.max()、.min()方法分别返回列表中的最大、最小值；
mylist = [1, 6, 234.23, 'adf', '张三']
print(mylist) # [1, 6, 234.23, 'adf', '张三']
print(mylist[2]) # 234.23
print(mylist[-1]) # 张三
print(mylist[:2]) # [1, 6]
print(6 in mylist) # True
print(mylist + ['哈哈']) # [1, 6, 234.23, 'adf', '张三', '哈哈']
a,b,c = mylist[:3]
print(a, b, c) # 1 6 234.23
print(len(mylist)) # 5
mylist.append('end')
print(mylist) # [1, 6, 234.23, 'adf', '张三', 'end']
print(mylist.index('张三')) # 4
mylist.pop()
print(mylist) # [1, 6, 234.23, 'adf', '张三']
mylist.reverse()
print(mylist) # ['张三', 'adf', 234.23, 6, 1]
7-2）元组
元组是不可改变的，因此元组没有列表中的append、pop、remove等的方法。
tup_1 = (1, 234.23, 'adf', '张三')
print(tup_1[2]) # adf
print(tup_1[:3]) # (1, 234.23, 'adf')
tup_2 = (1)
print(tup_2, type(tup_2)) # 1 <class 'int'>
tup_3 = (1,)
print(tup_3, type(tup_3)) # (1,) <class 'tuple'>
7-3）几种遍历方式：
遍历元组和遍历列表基本一致。
mylist = [1,2,3,4,5,6]
for e in mylist: # 遍历,e是mylist中的元素
print(e)
for i in range(0, len(mylist)): # 遍历，左闭右开 i 是索引
print(i, end='\t')
print(mylist[i])
''' for——else 结构 '''
for item in mylist:
print(item)
else:
print("循环结束")
''' while——else 结构 '''
i = 0
while i < len(mylist):
print(list[i])
i += 1
else:
print('循环结束')
7-4）列表与元组之间的转化
tuple(list）：列表转换成元组
list(tuple) ：元组转换成列表
list1 = [1,2,3,4,5]
tup1 = tuple(list1) # 列表转换成元组
print(tup1) # (1, 2, 3, 4, 5)
list2 = list(tup1) # 元组转换成列表
print(list2) # [1, 2, 3, 4, 5]
8、字典即其遍历方法
8-1）字典的基本操作
student = {
"name":'张三',
"age":24,
"gender":'男'
}
# 两种获取方法
print(student["name"]) # 张三
print(student.get("name")) # 张三
# 两种修改的方式
student["age"] += 1
print(student) # {'name': '张三', 'age': 25, 'gender': '男'}
student.update({"name":'王五', "age":18})
print(student) # {'name': '王五', 'age': 18, 'gender': '男'}
student["phone"] = "12312344212" # 新增
print(student) # {'name': '王五', 'age': 18, 'gender': '男', 'phone': '12312344212'}
student.pop('gender') # 删除某一项
print(student) # {'name': '王五', 'age': 18, 'phone': '12312344212'}
8-2）字典的遍历
for i in student: # 得到的 i 是 key
print(f"key:{i}, value:{student[i]}")
'''
key:name, value:王五
key:age, value:18
key:phone, value:12312344212
'''
for k in student.keys(): # 直接遍历键
print(k)
'''
name
age
phone
'''
for v in student.values(): # 直接遍历值
print(v)
'''
王五
18
12312344212
'''
for kv in student.items(): # 遍历出由键和值构造出来的元组
print(kv)
'''
('name', '王五')
('age', 18)
('phone', '12312344212')
'''
for k,v in student.items(): # 同时遍历键和值
print(k, v)
'''
name 王五
age 18
phone 12312344212
'''
9、函数
python 中的参数分为4类
1、必须参数（位置参数，positional argument）
2、默认参数（定义形参时可以指定一个默认值
3、可变长参数，可选参数 加 * 在前面来说明 接收到的数据将组成元组的形式
可变长参数必须放到必须参数后，同时建议放到默认参数后
4、字典参数，关键字参数， 字典参数需要在可变长参数之后 加 ** 在前面来说明
9-1）默认参数
def test_args_1(a, b, c = 100): # a、b是必须参数，c是默认参数，如果不传c，则c默认为100
print(a * b + c)
test_args_1(1, 2, 3) # 5
test_args_1(2, 3) # 106
test_args_1(c=12, a=3, b=4) # 能够正常工作，不必关心顺序问题 结果为 24
9-2）可变长参数
def test_args_2(a, b, *args):
print(args) # 可变长参数，以元组的形式存在 (3, 4)
print(*args) # 在元组或列表前面加 * 号，把元组和列表展开 3 4
res = 0
for item in args:
res += item
res += a + b
print(res) # 10
test_args_2(1, 2, 3, 4)9-3）字典参数（关键字参数）
def test_args_3(a, b, *args, **kwargs):
result = a + b
print(result) # 3
print(args) # (3,4,5)
print(kwargs) # {'name': '张三', 'age': 64}
# 字典参数中的键名不能与函数的形参名相同
test_args_3(1, 2, 3, 4, 5, name="张三", age=64)9-4）多种返回值
def test_func_1(a,b,c):
return a, [b, a], {"sum":a+b+c}
res = test_func_1(1,6,3)
print(res) # (1, [6, 1], {'sum': 10})
x,y,z = test_func_1(1,6,3)
print(x,y,z) # 1 [6, 1] {'sum': 10}9-5）匿名函数（lambda 表达式）
lambda 参数：返回值
lamb = lambda a, b : a + b
res = lamb(1, 2)
print(res) # 3
lamb_1 = lambda *args : sum(args)
res = lamb_1(1,2,3,4,5)
print(res) # 15
10、包和模块
模块 是包含python定义和语句的文件，每一个以.py后缀结尾的文件都可以看成是一个模块；
包 可以看成是包含若干个python模块的文件夹（目录），但是该目录下需要有一个 __init__.py 文件才能被识别为一个包（可以在需要的时候在目录下直接创建一个__init__.py 文件）；
在导入一个模块的时候，实际上是把该模块的代码重新执行了一遍；一个模块不管import了多少遍，只会执行一次；可以在任何需要的地方导入模块；
10-1）导入整个模块：
# 第一中方式
import math, re, os
print(math.sin(math.pi / 2)) # 需要 模块名.函数 或 模块名.变量名 这样的形式来使用
# 第二种方式
from math import *
print(sin(pi / 2)) # 可以直接使用
10-2）从模块中导入指定的内容：
# 从 math 模块中导入 sin 函数和 pi 模块变量
from math import sin,pi
print(sin(pi / 2))10-3）从包中导入模块等：
# 1
from parent_modules.child_modules.package_1 import testFunc
res = testFunc(1,2)
print(res)
# 2
from parent_modules.child_modules.package_1 import *
res = testFunc(1,2)
test('你好')
print(res)
# 3
from parent_modules.child_modules import package_1
package_1.test('你好啊')
