python 基础 基本数据类型

基本类型的补充

str --> 一次性创建的，不能被修改，强制修改就会在创建一个而之前的也会在

list -->允许重复的集合 修改  记录 链表，下一个元素的位置，上一个元素的位置

tuplt --> 允许重复的集合  修改

dict---> 允许重复的集合  修改

set -->不允许重复的集合，修改  也是不允许重复的列表

set 集合

创建方式有两种 s = set（） s = {，，，，}

s1 = {11,44,55,66,77}
b1 = {11,22,33,44,55,789}
s1.add(88)   #添加某一个元素 不能直接打印
print(s1)
结果
{66, 11, 44, 77, 55, 88}

s1.clear()   #清空列表 不能清除一个
print(s1)
结果
set()

i = s1.difference (b1)  #找s1中存在 b1中不存在的元素，并赋值给i
print(i)
结果‘
{66, 77}

s1.difference_update(b1)  #找某一个存在，某一个不存在元素更新自己的
print(s1)
结果
{66, 77}

i = s1.discard(11)
print(s1)   #移除指定元素  没有的也不存在保错
结果
{66, 44, 77, 55}

i = s1.remove(11)  #移除指定元素，不存在的报错
print(b1)
结果
{33, 11, 44, 789, 22, 55}

i = s1.intersection(b1)   #返回两个集合的交集作为一套新的
print(s1)
结果
{66, 11, 44, 77, 55}

i = s1.isdisjoint(b1)  #判断有没有交集，有交集就是False，没有交集就是Ture
print(i)
结果
False

i = s1.issubset(b1)  #判断是不是子序列
print(i)
结果
False

i = s1.issuperset(b1)  #判断是不是父子列
print(i)
结果
False

i = s1.pop()   #删除某一个元素 因为是无序的所以是随机 而删除掉的给会赋值给i变量
print(i)
结果
66
i = s1.symmetric_difference(b1)
print(i)    #对称交集  就s1中存在 b1中不存在的  b1中存在 s1中不存在的 并进行合集！
结果
{33, 789, 22, 77}

i = s1.union(b1)
print(i)   #并集 合并到一个新的集合
结果
{33, 11, 44, 77, 789, 22, 55}

li = [123,321,32113243]
s1.update()
print(li)
执行结果：[123, 321, 32113243]

三目运算 三元运算

name= 值1 if 1 == 1 sles 值2 如果条件成立就把值1赋给变量 如果条件不成立就把值2 赋给变量

q = 'erzi' if 1==1 else 'sunzi'
    print(q)

q = 'xin' if 1 !=1 else 'pi'
　　print(q)

D:\python3.5\python.exe D:/untitled/.idea/sanyuan.py
erzi
pi
Process finished with exit code 0

深浅拷贝。 深浅拷贝有copy模块。

导入模块：import copy

浅拷贝：copy.copy

深拷贝：deepcopy

字面理解：浅拷贝指仅仅拷贝数据集合的第一层数据，深拷贝指拷贝数据集合的所有层。

所以对于只有一层的数据集合来说深浅拷贝的意义是一样的，比如字符串，数字。

import copy    先导入模块

q1 = 123

print(id(q1))

q2 = q1

赋值

print(id(q2))

q3 =copy.copy(q1)

浅拷贝 print(id(q3))

q4 = copy.deepcopy(q1)

深拷贝 print(id(q4))

D:\python3.5\python.exe D:/untitled/q1.py

497237680

497237680

497237680

497237680

Process finished with exit code 0

对于字典、元祖、列表 而言，进行赋值、浅拷贝和深拷贝时，其内存地址的变化是不同

  赋值 只是创建一个变量，该变量指向原来内存地址，如：

q1 = {'k1':'v1','k2':'v2','k3':['xin',321]}
q2 = q1
print(id（q2)）

D:\python3.5\python.exe D:/untitled/q1.py
10040584

Process finished with exit code 0

浅拷贝 ，在内存中只额外创建第一层数据   拷贝加赋值 的id地址都一样的

q1 = {'k1':'v1','k2':'v2','k3':['xin',321]}
q2 = copy.copy(q1)
print(id(q1)，id（q2）)

D:\python3.5\python.exe D:/untitled/q1.py
7503144 15611144
Process finished with exit code 0

深拷贝，全部拷贝，除了最后一层的值
在内存中将所有的数据重新创建一份（排除最后一层，即：python内部对字符串和数字的优化）

q1 = {'k1':'v1','k2':'v2','k3':['xin',321]}
q2 = copy.deepcopy(q1)
print(id(q1),id(q2))

D:\python3.5\python.exe D:/untitled/q1.py
11238696 12160016

Process finished with exit code 0

函数：

函数 是面向过程编程

函数编程

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。

函数能提高应用的模块性，和代码的重复利用率。你已经知道Python提供了许多内建函数，比如print()。但你也可以自己创建函数，这被叫做用户自定义函数。

你可以定义一个由自己想要功能的函数，以下是简单的规则：

• 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()。
• 任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
• 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
• 函数内容以冒号起始，并且缩进。
• return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

定义函数
def xin():     # 只输入一次 以后可以直接调用 不需要继续重新输入或者复制粘贴
    print('qwertryu')
def kai():
    print('ertyuidfghjcvbnm')
# #执行函数
xin()   #从上往下执行
kai()

# return #就是返回值 每次执行完结果都要定义一个返回值，不定义自动返回HONE

def xin ():
    print('xinxinxin')
    return 'ok'   记得要定义返回值
ret = xin()
print(ret)
D:\python3.5\python.exe D:/untitled/.idea/sanyuan.py
xinxinxin
ok

Process finished with exit code 0

def xin():       定义函数名称
    print('qwe')
ret = xin()执行函数
if ret:          如果返回值是真的
    prtint('haha')  
else:             否则就是假的
    print('gun')
　　
D:\python3.5\python.exe D:/untitled/.idea/sanyuan.py
qwe
gun

Process finished with exit code 0

参数  分为 形式参数， 实际参数 ， 动态参数

形参 ，实参 （默认的，按照顺序）

指定 形参传入实参，可以不按照顺序

函数可以有默认参数，（有默认值的参数一定要放在参数的尾部）

动态参数  *，元祖 ，元祖的元素

　　　　　**，字典

　　　

形式参数  和 实际参数

def kai (i): #(i) 形式参数，
    if i == "123456789": #如果形式参数等于实际参数的值
        return True     # 就返回成功 下面的代码就不执行了
    else:               #否则
        return False    #就返回失败  继续执行

q1 = kai('123456789')    #实际参数就是定义的返回值
q2 = kai('789465132')
if q1:                    #如果执行的实际参数是就是形式参数
    print('yes')          #就是成功了
else:                    #否则
    print('no')          #否则就是失败了

D:\python3.5\python.exe D:/untitled/.idea/sanyuan.py
yes

Process finished with exit code 0

执行参数：

def xin(w,x ):
        print(w,x)
        return'sss'
s = xin(x= 'xx',w= '')
print(s)
执行结果：
33 xx
sss

动态参数

加 * 号就是动态参数
def niu(*a):
    print(a,type(a))   #元祖类型
niu(123,456,543,654,432,654,423)

D:\python3.5\python.exe D:/untitled/.idea/sanyuan.py
(123, 456, 543, 654, 432, 654, 423) <class 'tuple'>

Process finished with exit code 0

def niu (**a):  # 字典类型
    print(a,type(a))
niu(k1=123,k2=456)
D:\python3.5\python.exe D:/untitled/.idea/sanyuan.py
{'k1': 123, 'k2': 456} <class 'dict'>

Process finished with exit code 0

def xin (*a,**aa):       接受和各种类型的参数
    print(a,type(a))
    print(aa,type(aa))
xin(11,22,k1=23,k2 =123)

D:\python3.5\python.exe D:/untitled/.idea/sanyuan.py
(11, 22) <class 'tuple'>
{'k2': 123, 'k1': 23} <class 'dict'>

Process finished with exit code 0

一般把一个 *写成  args

　　　　　　　　　** kwargs

　　　　　　　　也可以写成 *a。**aa。

def q1(* args):
    print(args,type(args))
li = [1,2,3,4,5]
q1(li)         元祖里的一个元素
q1(*li)   把每个元素都加入到 元祖里

D:\python3.5\python.exe D:/untitled/.idea/sanyuan.py
([1, 2, 3, 4, 5],) <class 'tuple'>
(1, 2, 3, 4, 5) <class 'tuple'>

Process finished with exit code 0

全局变量 局部变量

定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。

局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。调用函数时，所有在函数内声明的变量名称都将被加入到作用域中。

PERSON = 'alex'
###全局变量  全局变量都大写不能被修改 如果要修改的话必须加global
def x1 ():
    a = 12
    #局部变量 ，都为小写只能在自己的范围内
    print(PERSON)
    print(a)
x1()

D:\python3.5\python.exe D:/untitled/.idea/sanyuan.py
alex
12

Process finished with exit code 0