python基础部分(二)

一、字符串的相关操作

1、首字母变大写
用capitalize()方法，原字符串不会改变。

s="dasfvghasdf"
print(s.capitalize())

程序输出结果为：

F:\lei\venv\Scripts\python.exe F:/lei/lei/test.py
Dasfvghasdf

Process finished with exit code 0

2、把字符串中每个单词的首字母大写（遇见非字母，后边大写）
用title()方法

s="da sfvg has df"
print(s.title())

程序输出结果为：

F:\lei\venv\Scripts\python.exe F:/lei/lei/test.py
Da Sfvg Has Df

Process finished with exit code 0

3、所有字母大写，用upper方法。

s="da sfvg has df"
print(s.upper())

程序输出结果为：

DA SFVG HAS DF

常用操作：验证码

verifyCode="aEmn"
veri=input("请输入你的验证码(%s)"%verifyCode)
if veri.upper()==verifyCode.upper():
    print("验证码正确")
else:
    print("验证码错误")

4、所有字母变小写，用lower()方法

verifyCode="aEmn"
print(verifyCode.lower())

程序输出结果为：

aemn

lower()方法对欧洲某些字符转换不了小写，
casefold()方法可以。
5、小写变大写，大写变小写的方法
swapcase()方法

a="I love You"
print(a.swapcase())

程序输出结果为：

i LOVE yOU

6、center(长度)字符串居中。

a="I love You"
print(a.center(20,"_"))#用下划线填充

程序输出结果为：

_____I love You_____

7、去掉字符串中的空格，用strip()方法，去掉左右两端的空格，\t,\n。

a="   I love You  "
print(a.strip())

程序输出结果为：

I love You

用户登录的例子：

username=input("请输入你的名字：").strip()
password=input("请输入你的密码：").strip()
if username=="alex" and password=="123":
    print("登录成功")
else:
    print("登录失败")

strip(字符串)可以去掉左右两端次相同的字符串
8、字符串替换replace()

s="good alex good wusir"
s1=s.replace("good","sb")
print(s1)

程序输出结果为：

sb alex sb wusir

replace(old,new,time(替换的次数))

s="good alex good wusir"
s1=s.replace("good","sb",1)
print(s1)

程序输出结果为：

sb alex good wusir

9、字符串的切割
用split()方法，返回一个列表。

s="alex_wusir_taibai_taigao_liang"
lst=s.split("_")
print(lst)

程序输出结果为;

['alex', 'wusir', 'taibai', 'taigao', 'liang']

注：把头切割返回空。
10、格式化输出

name="alex"
age=18
hobby="basketball"
print("我叫%s,今年%d,喜欢%s"%(name,age,hobby))
print("我叫{}，今年{},喜欢{}".format(name,age,hobby))
print("我叫{0}，今年{1}，喜欢{2}".format(name,age,hobby))
print(f"我叫{name},今年{age},喜欢{hobby}")

程序输出结果为：

我叫alex,今年18,喜欢basketball
我叫alex，今年18,喜欢basketball
我叫alex，今年18，喜欢basketball
我叫alex,今年18,喜欢basketball

11、查找
①判断字符串是否以啥开头（判断姓氏）
用startswitch()方法。

s="java_python_区块链_大数据"
print(s.startswith("java"))

程序输出结果为：

True

例二

a=["上官","欧阳","董","王"]
name=input("请输入你的名字:")
for el in a:
    if name.startswith(el):
        print("名字在百家姓里面")
        break
else:
    print("名字不在百家姓里面")

②判断字符串以啥结尾
用endswitch()方法
③数数
用count()方法

s="java_python_区块链_大数据"
print(s.count("a"))

程序输出结果为：

2

④查找find(),如果存在，返回索引，不存在，返回-1

s="java_python_区块链_大数据"
print(s.find("a"))

程序输出结果为：

 1

index()找到，返回索引，找不到报错
⑤判断字符串是否由基本的字母和中文组成
用isalpha()方法。

s="javapython区块链大数据"
print(s.isalpha())

程序输出结果为：

True

⑥判断是否由数字组成：
用isdigit()方法。只能识别阿拉伯数字（1234567890）
用i是numeric()方法,能识别（1234567890，一二三，壹，贰，叁，仨）
⑦判断字符串长度

s="javapython区块链大数据"
print(len(s))

⑧迭代（把一句话中的每个字符拿到）

s="javapython区块链大数据"
i=0
while i<len(s):
    print(s[i])
    i+=1

另一种方法：

s="javapython区块链大数据"
for i in s:
    print(i)

把字符串s中的每一个元素赋值给i
注：for循环必须为可迭代对象。
for 变量 in 可迭代对象：
循环体（break，continue）
缺点：无法看到索引

二、列表和元组及相关操作

1、什么是列表？
①定义：能装对象的对象。
相当于把很多东西(对象)放在一个塑料袋里。
在python用[]来描述列表，中间用逗号隔开，对数据类型没有要求。

lst=["光头强","胸大","熊二",["周杰伦","周润发"]]

列表存在索引和切片，和字符串一样。
切片操作前后，数据类型不变

②相关的增删改查操作。
1、增，注意，list可以发生改变，可以在原始上进行增删改查。
append()方法在后面追加。

lst=["魔鬼","天使"]
lst.append("美女")
print(lst)

程序输出结果为：

['魔鬼', '天使', '美女']

insert(位置，元素)方法，在某个部分插入，效率比较低。

lst=["魔鬼","天使"]
lst.insert(1,"美女")
print(lst)

程序输出结果为：

['魔鬼', '美女', '天使']

extend()方法，迭代添加。

lst=["魔鬼","天使"]
lst.extend(["神仙","凡人"])
print(lst)

程序输出结果为：

['魔鬼', '天使', '神仙', '凡人']

2、删除
pop()方法，从后往前删除。

lst=["das","asd","rqwr"]
lst.pop()
print(lst)

pop(索引) 按照索引位置删除

lst=["das","asd","rqwr"]
lst.pop(0)
print(lst)

remove(元素)移除

lst.remove("asd")

del()用切片或者索引删除。

lst=["das","asd","rqwr"]
del lst[:1]
print(lst)

clear()清空列表。

lst=["das","asd","rqwr"]
lst.clear()
print(lst)

3、修改（用索引或者切片修改）

lst=["武松","潘长江","宋江"]
lst[2]="罪人"
print(lst)

程序输出结果为：

['武松', '潘长江', '罪人']

注：IndexError: list assignment index out of range
索引下标越界。

lst=["武松","潘长江","宋江"]
lst[1:3]="罪人"
print(lst)

程序输出结果为：

['武松', '罪', '人']

当迭代更新的时候，元素的个数必须要和切片的个数一致。
4、查找
查找每一个元素。

lst=["武松","dasd","宋江"]
for i in lst:
    print(i)

5、列表的嵌套

lst=[["武松","dasd","宋江"],["李安","王家卫","王晶"]]
print(lst[1][1])

程序输出结果为：

王家卫

降维操作：当出现多层嵌套，数数。
6、排序
sort()方法，排序，升序。

n=[1,4,2,5,6,4,67,23,653,67]
n.sort()
print(n)

程序输出结果为：

[1, 2, 4, 4, 5, 6, 23, 67, 67, 653]

sort(reverse=True)排序，降序。

n=[1,4,2,5,6,4,67,23,653,67]
n.sort(reverse=True)
print(n)

程序输出结果为：

[653, 67, 67, 23, 6, 5, 4, 4, 2, 1]

**注：**当单独使用reverse()方法时，表示翻转。

name=["林华并","小战无","排长"]
name.reverse()
print(name)

程序输出结果为：

['排长', '小战无', '林华并']

元组的相关操作

1、元组用()表示，只读。

tu=("DNF","LOL","王者荣耀","炫舞")
print(tu)

程序输出结果为：

('DNF', 'LOL', '王者荣耀', '炫舞')

元组也有索引和切片操作。
**注：**空元组 tu=tuple()表示，固定写法。
元组中如果只有一个元素。
tu=(1)不是元组

tu=(1)
print(type(tu))
<class 'int'>

tu=(1,)表示元组中的一个元素。

tu=(1,)
print(type(tu))
<class 'tuple'>

2、元组的嵌套
元组中的嵌套如果有列表，则可进行增删改查操作。

tu=(1,"哈哈",["忍者","神鬼"])
tu[2][1]="呵呵"
print(tu)

程序输出结果为：

(1, '哈哈', ['忍者', '呵呵'])

range(重点，难点)

1、

 for i in range(10):
        print(i)

程序输出结果为：

0
1
2
3
4
5
6
7
8
9

range(参数1，参数2)，顾头不顾尾。
range(参数1，参数2，参数3)
例子：用循环拿到列表全部的某一项，
第一种方法：

name=("林华并","小战无","排长")
for item in name:
    print(item)

但是这种方法拿不到索引。
第二种方法：

name=("林华并","小战无","排长")
for i in range(len(name)):
    print(name[i])

这种方法可以拿到元素的索引。
i 表示索引，name[i]为元素。

三、字典及其相关操作（增删改查，嵌套）

四、深浅拷贝

为什么要有深浅拷贝？
提高创建对象的速度。
计算机中最慢的是创建对象，需要创建内存。
最快的方式是二进制流的形式进行复制。
（做作业和抄作业？那个更快？）

copy()拷贝、抄作业、可以帮我们创建新的对象，和原来长的一样，浅拷贝。

li=["alex","ton","jim"]
do=li.copy()
print(li)
print(do)
print(id(li))
print(id(do))

输出结果为：

['alex', 'ton', 'jim']
['alex', 'ton', 'jim']
2280885287752
2280884415560

只是复制，创建新的地址。
列表嵌套，会创建多个地址，在copy()的时候，会拷贝多个地址，当修改嵌套列表内容时，拷贝的列表内容也跟着改变。

lst1=["alex","ton","jim",["das","hidf"]]
lst2=lst1.copy()  #浅拷贝，只拷贝第一层内容。
print(id(lst1))
print(id(lst2))
print(lst1)
print(lst2)

lst1[3].append("kevin")
print(lst1)
print(lst2)

程序输出结果为：

2638375103560
2638375975624
['alex', 'ton', 'jim', ['das', 'hidf']]
['alex', 'ton', 'jim', ['das', 'hidf']]
['alex', 'ton', 'jim', ['das', 'hidf', 'kevin']]
['alex', 'ton', 'jim', ['das', 'hidf', 'kevin']]

两个列表都添加了kevin。
深拷贝对象内部的内容都要复制一份。
步骤：
①引入一个模块，copy
②copy.deepcopy() 对象克隆

import copy
lst1=["alex","ton","jim",["das","hidf"]]
lst2=copy.deepcopy(lst1)
print(id(lst1))
print(id(lst2))
print(lst1)
print(lst2)

lst1[3].append("kevin")
print(lst1)
print(lst2)

程序输出结果为：

1817185942600
1817185943432
['alex', 'ton', 'jim', ['das', 'hidf']]
['alex', 'ton', 'jim', ['das', 'hidf']]
['alex', 'ton', 'jim', ['das', 'hidf', 'kevin']]
['alex', 'ton', 'jim', ['das', 'hidf']]

五、文件操作

以字节的形式操作文件。
①、f = open(文件路径，mode=“打开方式”，encoding=“编码格式”)
打开一个文件的时候获取到的是一个文件句柄。
从文件中读取数据

f = open("xiaoer.txt",mode="r",encoding="UTF-8")
content = f.read() #读取全部内容，光标在最后。再读取的话，读不到内容。
print(content)
f.close()#关闭连接

1、f.read(n)读取n个字符。
2、f.readline()读取文件一行
f.readline().strip()去除(空格、换行)
或者(f.readline(),end=" ")
3、f.readlines()一次性读取全部内容到列表中。
4、文件句柄是一个可迭代对象。

f = open("fufu",mode="r",encoding="UTF-8")
for line in f:
    print(line.strip())
f.close()

程序输出结果为：

两个大魔王
dasdas
qwerqwarq
adsr
说的那司法活动
大撒反对你jka

**优点：**节省内存，操作相对简单。
从文件中写操作

②mode:
r:只读
w:可写
a:
③、文件路径的问题
1、相对路径：相对于当前程序所在的文件夹，如果在文件夹内，随便找，直接写名字。
如果不在当前文件夹，可能需要出文件夹

f = open("../fufu",mode="r",encoding="UTF-8")

出一个文件夹，加一个（…/）
2、绝对路径
从磁盘的根目录寻找路径。
只有记录日志的时候可以用到绝对路径。
对文件的实际操作

f = open("无敌人生",mode="r",encoding="utf-8")
# 编号，名称，价格
# 1，香蕉，1.85
# 2，苹果，3.6
# 3，榴莲，3.5
line = f.readline().strip()
title = line.split(",")
lst = []
for line in f:
    dic = {}
    line = line.strip()
    data = line.split(",")
    for i in range(len(title)):
        dic[title[i]] = data[i]
    lst.append(dic)
print(lst)

程序输出结果为：

[{'编号': '1', '名称': '香蕉', '价格': '1.85'}, {'编号': '2', '名称': '苹果', '价格': '3.6'}, {'编号': '3', '名称': '榴莲', '价格': '3.5'}]

六、函数

**1、什么是函数？
y = x+1
计算机里的函数是对功能或者动作的封装。

2、函数的语法和定义

def sum():#定义一个动作
    print("哈哈")
    print("嘿嘿")
    print("哈哈")
    print("哈哈")
    print("哈哈")
    return "函数从上往下执行结束后，返回的结果"
#调用函数
sum() #这里调用的函数，return的返回值返回到这里。
#当返回多个结果，返回的是元组


   return "xiaojiejie","小姐姐"

程序输出结果为：

('xiaojiejie', '小姐姐')

def 函数名():
函数体
调用：
函数名()
print（sum）

<function sum at 0x00000185EA352EA0>

函数名放的是内存地址。
3、关于函数的返回值
函数可以有返回值，也可以没有返回值。
当函数没有返回值时，程序执行结束，返回的是None。
在函数末尾只写了return，没写返回值，则返回None。
当程序看到return，则不再执行程序。
在返回多个值时，会以一个元组返回
4、函数的参数（部分）**
小括号表示调用
在括号内写的东西叫参数
在函数声明的地方，写的参数时形参
在函数调用的地方，写的参数是实参
把实参传递给形参的过程叫做传参。

def max(tool): #形参
    print("打开%s"%(tool))
max("微信")  #实参

在函数调用的时候，必须保证所有的实参都有值。
关于实参
1、位置参数

def max(tool,a,b):
    print("打开%s,%s,%s"%(tool,a,b))
max("微信","扣扣","支付宝")

相对位置传参。

打开微信,扣扣,支付宝

2、关键字参数

def max(tool,a,b):
    print("打开%s,%s,%s"%(tool,a,b))
max(a="扣扣",b="支付宝",tool="微信")

3、混合参数

def max(tool,a,b):
    print("打开%s,%s,%s"%(tool,a,b))
max("支付宝",a="微信",b="扣扣")

顺序和关键字参数相对位置不能变，关键字参数必须在位置参数后面。
5、动态传参
，**
形参：聚合
位置参数 ->元组
关键参数** ->字典
实参：打散
列表，字符串，元素 -> *
字典 ->**
形参顺序:
位置参数，*args，默认值，**kwargs
无敌传参

def func(*args,**kwargs): #arguments参数 keyword-arguments关键字参数
	pass

2、作用域和名称空间(点名表)
名称空间：用来存放名字（变量，函数名，类名，引入的模块名）
1、全局名称空间：我们在py文件中自己写的变量，函数。。。
2、内置名称空间：我们在python解释器提供的一些内置内容（print,input）
3、局部名称空间：在我们执行函数的时候，会产生一个局部名称空间，放的是：函数内部的内容（变量，函数，类。。。）
作用域
1、全局作用域：内置+全局
2、局部作用域：局部自己。
注：不能从全局找局部
能从局部找全局
globals()查看全局作用域中的内容
locals()查看当前作用域中的内容
3、函数的嵌套
定义：在函数中声明函数

 def outer():
    def inner():
        print("我的天那")
    print("还可以这样写？")
    inner()
outer()
#inner()在全局不能找局部，否则报错

例二

a = 10
def func():
    a=20
    print(a)
func()
print(a)

程序输出结果为：

20
10

注：全局变量尽量不要用global引入到局部。
不管在哪里调用，都用全局的变量。
nonlocal 在局部，寻找离它最近的外层的一个变量。
如果没有nonlocal和global，查找顺序，自己，上一层，上一层，上一层。

a = 50
def func1():
    # a = 10 局部
    def func2():
        nonlocal a #不找全局，global找全局，上一层没有a，报错
        a += 10

        print("func2",a)
        func2()
        print(a)
func1()
print(a)

例三

def func():
    hua = ["♥","♠","♣","♦"]
    num = ["A",1,2,3,4,5,6,7,8,9,10,"J","Q","K"]
    result = []
    for h in hua:
        for n in num:
            result.append((h,n))
    return result
print(func())

程序输出结果为：

[('♥', 'A'), ('♥', 1), ('♥', 2), ('♥', 3), ('♥', 4), ('♥', 5), ('♥', 6), ('♥', 7), ('♥', 8), ('♥', 9), ('♥', 10), ('♥', 'J'), ('♥', 'Q'), ('♥', 'K'), ('♠', 'A'), ('♠', 1), ('♠', 2), ('♠', 3), ('♠', 4), ('♠', 5), ('♠', 6), ('♠', 7), ('♠', 8), ('♠', 9), ('♠', 10), ('♠', 'J'), ('♠', 'Q'), ('♠', 'K'), ('♣', 'A'), ('♣', 1), ('♣', 2), ('♣', 3), ('♣', 4), ('♣', 5), ('♣', 6), ('♣', 7), ('♣', 8), ('♣', 9), ('♣', 10), ('♣', 'J'), ('♣', 'Q'), ('♣', 'K'), ('♦', 'A'), ('♦', 1), ('♦', 2), ('♦', 3), ('♦', 4), ('♦', 5), ('♦', 6), ('♦', 7), ('♦', 8), ('♦', 9), ('♦', 10), ('♦', 'J'), ('♦', 'Q'), ('♦', 'K')]

九九乘法表

for i in range(1,10):
    for j in range(1,i+1):
        print("%s x %s = %s"%(i,j,i*j),end=" ")
    print() #换行