python 笔记（1）——基础和常用部分

目录

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 

tup_3 = (1,)
print(tup_3, type(tup_3))       # (1,) 

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('你好啊')