python基础

list列表

num = [1,2,3,4,5]
print(num)
#优点：python支持不同数据类型可以混合存储在一个列表中
#缺点：会导致数据存储不紧凑，整个结构占用很多空间
num1 = [1,'python',3.1415926,]
print(num1)

#sum（）：求和
print(sum(num))


#len（）：统计列表中元素的个数
print(len(num))

#num[n]根据索引查找元素
print(num[0])#列表的索引就是元素所在的位置
#print(num[4])
print(num[-1])#负数就是从最后一个字计算索引
#print(num[-2])
#print(num[-4])

#方括号左边是闭区间，右边是开区间
print(num[0:3])#输出的结果就是索引0-2的元素
print(num[1:4])

#索引的特殊用法
print(num[0:])#从索引0开始，全部输出
print(num[:-1])#输出截至到-1
print(num[-4:-1])
print(num[-1:])


#insert:第一个参数表示插入的索引位置（下标），第二个参数表示插入的值
num.insert(0,123)
print(num)

#insert():指定插入到索引位置元素，第一个参数表示索引，第二个参数表示插入的值
#num.insert(1,777)
#print(num)

#append:将值添加到列表的末尾
num.append(789)
num.append(1)
print(num)

#pop：删除特定位置的元素，并返回被删除的索引位置的值
print(num.pop(3))
#num.pop()  pop函数不传参时，默认删除列表的最后一个元素
print(num)
#del num[0:3]删除索引是0-3的元素

#更改元素不需要用到函数，直接选取元素，重新赋值
num[0]= 1
print(num)

#多维列表
name = ['张三','李四','王五']
sex = ['男','男','女']
age = [18,19,20]
print(name[0],sex[0],age[0])

#列表中可以嵌套列表 ，列表之间逗号分隔
student = [
    ['张三','男',18],
    ['李四','男',19],
    ['王五','男',20],
]

print(student[0])

print(student[1][1])#查找李四的性别，第一个参数表示第一层索引，第二个参数表示第二层索引

#快速创建多维列表
row =[0]*3
print(row)

m =[row] * 4
print(m)

m[1][0]=1
print(m)

#列表的常用方法
#append：向列表添加单个元素，默认添加到列表的最后（参数，元素）
num.append(999)
print(num)

#count:返回指定元素在列表中出现了几次
print(num.count(1))

#extend:将一个列表的元素添加到另一个列表
num2=[111,222,333]
num.extend(num2)
print(num)

#index():返回列表中指定元素所在的索引
print(num.index(2))
print(num)


#pop():将列表中指定索引位置处的元素，并返回这个元素（参数：索引）
print(num.pop(6))#返回的是被删除的值
print(num)#打印删除后的列表

#remove:删除。如果有重复的元素，删除从左往右数第一个出现的，
#num.remove(777)#参数是元素
#print(num)


#reverse():将列表中的元素逆序排列。（不需要传参）
num.reverse()
print(num)

#sort():将列表中的元素按照从小到大顺序排列
num.sort()
print(num)

print(max(num))#max:取最大值

print(num[-1])#取最大值

#copy:复制列表，不需要传参
num3 = num.copy()#copy:复制列表，不需要传参
print(num3)

#clear():清空列表
num3.clear()
print(num3)

tuple元组

列表和元组的共同点：
可以存储不同数据类型的数据，但是数据存储不紧凑。查询方法相同

           不同点：列表是以动态数组实现的，可以进行增删改查
                  元组不能动态的增改，可以删查

##元组
#定义可以不使用小括号，使用小括号
#可以包含任意数据类型的元素,但是会导致数据存储不紧凑,占用更大的空间
#元组可以作为简化版的列表,因为它的不可更改性,所以很多时候可以作为常量使用,防止被算改 
t ="小明",1,2.33
print(type(t))#type:验证数据类型
t1=(1,2,3,4,5,t)#列表可以嵌套列表，元组可以嵌套元组
print(t1)
print(type(t1))
####元组中的对象是不可变的,不能动态的添加或修改元素,元组中所有的元素都必须在创建的时候定义

#t[0] = 111 报错 不能修改

#查询
print(t1[0])
print(t1[-1])
print(t1[1:5])

dict字典

python
 字典
 优点：可以高效的查找，插入，删除任意给定键关联的对象
 缺点：占用内存大
dict是空间换时间，列表是时间换空间

#key相当于索引（下标）
from collections import namedtuple


d ={'tom':20,'jack':21,'lili':22}
print(type(d))
print(d)
#key是唯一的不能修改，value可以对应各种数据类型
dict = {'tom':20,'jack':21,'lili':22}
print(dict)

#查找：如果传入的key存在，就返回对应的value，如果key不存在就会报错keyerror 例：print(d['ttt'])
#print(d['ttt'])
print(d['tom'])

#修改：和列表一样，修改时不需要函数，直接通过赋值修改value。可以修改value，但是不能修改key
d['tom']=90#key一旦定义，就无法修改！如果不存在，就会把键和值都添加进去
print(d)

#增：如果key不存在，就增加进去
d['Aaaa']= 300
print(d)

#删除：和列表一样，使用pop函数
print(d.pop('jack'))
print(d)

#type：返回变量的类型
print(type(d))

#del:删除对应的KV
print(d)
del d['Aaaa']
print(d)

#k in d:返回k是否在d这个字典里面 如果在返回true ，如果不在返回false
print('tom' in d)

#.keys():返回字典中所有的key信息
print(d.keys())

#.values()：返回字典中所有的value值的信息
print(d.values())


#items():返回字典中所有的键值信息
#items函数，将KV变成了元组tuple的形式，以数组的方式输出
print(d.items())

#list():转化为列表 先用items 再用list
print(list(d.items()))

#列表可以嵌套列表，元组可以嵌套元组，字典也可嵌套字典
dict = {
    1:{'name':'蔡徐坤','age':20},
    2:{'name':'姜云升','age':25},
    3:{'name':'吴亦凡','age':30}
}
print(dict)
#字典中key作为索引存储
print(dict[1]['name'])#传入索引 查看蔡徐坤名字 第一层的索引（key）是1,第二层索引是'name'

D = {'中国':'北京','美国':'华盛顿','法国':'巴黎'}
print('中国' in D)
print(D.keys())
print(D.values())


#.get():如果key存在，就返回对应的value，如果不存在就返回None
print(dict.get(1))
print(dict.get(4))



#.pop():key存在，就删除并返回被删除的键所对应的值value，如果不存在就会报错！
print("===============================")
#print(dict.pop(3))
#print(dict)

#.popitem():返回并且删除字典中最后一对键值对,如果不存在就报错
p = dict.popitem()
print(p)
print(dict)

#copy():复制
c=dict.copy()
print("c:",c)

#len():统计列表中元素的个数
print(len(c))

#.clear():清空
dict.clear()
print(dict)

set集合

#集合
#特点：集合是一种无序列表，集合中的元素具有唯一性(可以用来去重，不存在相同的元素)
#     为了确保集合中不包含相同的元素，规定集合中放入的元素只能是不可变类型，eg:数字，字符串，元组

#1.集合的生成:
a = {1,2,3}  #空的花括号生成的是字典，里面添加元素之后就成了集合
print(type(a))
b = set({})#创建空集合用set,其他类型转化为集合
print(type(b))

s = [1,2,3]
print(type(s))
s = set(s)
print(type(s))

#2.集合的基本运算
#并集，交集，差集，补集

#(1)并集 | .union()
#(2)交集 & .intersection()
#(3)差集 - .difference()
#(4)补集 ^ .symmetric_difference()

a,b = {1,2,3,4},{3,4,5,6}
#(1)并集 | .union() : 返回的是两个集合中所有元素的集合，并集运算可以交换
print(a|b)
print(b|a)
print(a.union(b))
print(b.union(a))
print("========================================")


#(2)交集 & .intersection()  ：返回的是两个集合中共有元素的集合，交集运算可以交换
print(a & b)
print(b & a)
print(a.intersection(b))
print(b.intersection(a))
print("========================================")
#(3)差集 - .difference()   :返回第一个集合但不在第二个集合中的元素组成的集合，差集运算不能交换
print(a-b)
print(b-a)
print(a.difference(b))
print(b.difference(a))
print("========================================")

#(4)补集 ^ .symmetric_difference()  :并集与交集的差，补集运算可以交换
print(a^b)
print(b^a)
print(a.symmetric_difference(b))
print(b.symmetric_difference(a))



#真子集

c = {1,2,3}
d = {1,2}
print(d<=c)
print(d>=c)
#子集
print(d<c)
print(d>c)

#判断从属关系
print("判断结果为：",4 in c)
print("############################################################################################")

a,b = {1,2,3,4,5},{3,4,5,6,7,8}
print(a.difference(b))
print(a,b)
# difference_update(): 移除集合中并且存在与第二个集合中的元素
a.difference_update(b)
print(a,b)

print(a.intersection(b))
print(a,b)
a.intersection_update(b)
print(a,b)



print(a.symmetric_difference(b))
print(a,b)
a.symmetric_difference_update(b)
print(a,b)



#集合的添加 :如果添加了重复的元素，不会进行任何操作
a.add(888)

print(a)

a.update([7,8])
print(a)

#集合的删除
a,b = {'马化腾','马云','肖战'},{'肖战','杨紫','黄子韬'}

#pop随机删除
# print(a.pop())
# print(a,b)

# remove：如果需要删除的元素不存在，会报错
#a.remove('黄子韬')

# discard()  ：如果删除的元素不存在，不会报错
# a.discard('黄子韬')

#集合的复制
f1 = a.copy()
print(f1)


# #清空
# f1.clear()
# print(f1)

"""
不可变数据类型：当该数据类型的对应变量的值发生了改变，那么它对应的内存地址也会发生发改变
对于这种数据类型，就称不可变数据类型。(整型，字符串，元组)

可变数据类型： 当该数据类型对应变量的值发生了改变，那么它对应的内存地址不发生改变，
对于这种数据类型，就称可变数据类型。(列表，集合，字典)

"""

s1 = set({})
print(s1)
s1.add('猫咪')
s1.add('萨摩耶')
s1.add('英短')

print(s1)
s1.pop()
print(s1)
print('判断结果为：','小白'in s1)
s2=s1.copy()
print(s2)
s2.clear()
print(s2)

import

#import 模块
# import 导入单个模块
#import 模块名1[as 别名1],模块名2[as 别名2]
#import sys
# 模块名，成员
#print('程序存储位置：'+sys.argv[0]): 程序存储的位置
# import sys as s
# print('别名调用：'+s.argv[0])

#import导入多个模块

# import sys,os
# print('存储位置：'+sys.argv[0])
# print('平台上路径分隔符'+os.sep) #sep: 平台上路径分隔符 /


# import sys as s,os as o  #起别名 ，用别名调用
# print(s.argv[0])
# print(o.sep)



#不推荐使用
#from 模块名 import 成员名1[as 别名1],成员名2[as 别名2] 
# from sys import argv as v
# print('直接调用成员，不加模块前缀'+argv)

# print('直接调用成员，不加模块前缀:'+v[0])


# from sys import argv as v,winver as wv
# print('存储地址：'+v[0])
# print('使用的python版本号：'+wv)

'''
###导入sys模块中所有成员(不建议)不同模块的相同成员名调用的时候，无法清楚的区分相同成员名的成员来自哪个模块

from sys import *

from m1 import * 成员
from m2 import *  foo成员
foo()  #python不知道要调用哪里面的foo成员

from m1 
from m2                        ### 调用成员必须加前缀，这样就更好区分哪个成员是哪个模块里的
m1.foo()
m2.foo()

from m1 import foo as foo1      ###调用这个成员的时候，给他们起一个个性的别名
from m2 import foo as foo2
foo1()
foo2()



'''


'''
自定义说明文档要在模块的开头定义
demo 模块中包含以下内容：
name 字符串变量：初始值为'汉服'
cradle    字符串变量：初始值为'中国'
say() 函数
'''

name = '汉服'
cradle = '中国'
print(name,cradle)



def say():
    print('人生苦短，我用python')


if __name__ == '__main__':
    say()

function函数

#数字相关的内置函数

#1.绝对值的计算：abs
print(abs(-7))
print(abs(7))


#2.进制的转换： bin() , oct() ,hex()
print(bin(100))
print(oct(100))
print(hex(100))

#3.Ascll码表与字符的转换 chr ，ord
print(chr(37))
print(ord('@'))

#4.商和余数的计算：divmod()
print(divmod(10,3))   #10//3  10%3

#5.幂的计算 ：pow
print(pow(2,5))  #2**5
print(pow(10,10,2)) #10**10 % 2

#6.近似值的计算 ： round() :规定，将数字近似到离0更远的一边，距离一样远的话，就保留到偶数的一边
print(round(2.5678)) #一个参数，保留整数部分
print(round(4.678,2)) #两个参数，第二个参数是保留多少位
print(round(0.5))#
print(round(-0.5))


#序列相关的内置函数
#1.序列真假的判断：all() ,any()
#元素除了0，空，none，false外 都返回true


#all:所有元素为真，就返回true
print(all(['12','小明',1.22,[7,8,9,]]))

#any：序列里有任意元素为真，就返回true
print(any(['','小明',1.22,[7,8,9,]]))


#2.迭代对象的生成 range()
print(range(10))  #一个参数，默认从0开始
print(list(range(5,9)))#两个参数，从指定的参数开始
print(list(range(10))) #两个参数，从指定的参数开始


#3.序列的迭代     enumerate()  , zip()
#enumerate():在迭代序列时输出序号和值
for i,c in enumerate('abc'):
    print(i,c)

print('*********')
#zip() : 将多个序列放在一起迭代
for i , c in zip('123','abc'):
    print(i,c)    

#序列的最值，max() , min() 
print(max(1,333,44,100))

print(min(1,333,44,100))

print('-------------------------------------------')
#序列的切片：slice()  三个参数，开始，结束，间距
# s1 =list(range(20)) 
for i in range(20)[slice(3,15,2)]:
    print(i)


#6.序列排序和逆序
w1 = [4,66,22,99,10,1]
reversed(w1)

sorted(w1)

print(sorted(w1))
print(reversed(w1))


#类型相关的内置函数
a = [1,2,3]
print(isinstance(a,list))#判断某个对象 是不是某种类型
print(type(a))# 返回这个对象是什么类型

#类型之间的转换
print(int('123'))
print(str(123))
print(float(1))

print(str(1.2+3.4))#适合人阅读
print(repr(1.2+3.4))#适合机器阅读

# t = (1,2,3)
# t1 = [1,2,3]
# #list
# list(t)
# set(t)
# dict(t)
# tuple(t1)

def

#自定义函数
#def 引导，参数可以为空，但是括号不能省略  代码的缩进
#带参数
def add (x,y):
    a = x + y
    return a
def add1(x,y):
    a = x + y
    b = x ** y
    c = x - y

    return a,b,c

#print(add(8,2))

#带默认参数
def add2(x,a=3,b=2,c=8):
    return a*x**2+b*x+c




#不定长参数
def add3(x,*ys):  #*ys:可变数目的参数
    total = x
    for i in ys:
        total+=i
    return total

def add4(x,**ys):  #**ys本质上是字典
    print(x)
    print(ys)


def add5(*x,**y):
    print(x,y)



#不带参数
def add6():
    print("你好")
    print("今天星期一")




#别的文件导包，不会执行这里面的内容，只会在本文件中执行
if __name__ == "__main__":  #__main__是两个下划线

    #Pyhton 提供了两种传参方式：顺序传入，键值对传参
    print(add(3,5))     #顺序传入
    print(add(x=6,y=8))  #键值对传参
    print(add('pyt','hon'))


    #print(add('python',123))#报错，传入的参数不支持某种操作，比如字符串和整形   
    #print(add(12,3,4)) #传入的参数数目和实际规定不符
    #print(add(4,x=5))#不能给同一个值赋值多次                以上三种情况会抛出异常


    #带默认参数的函数的调用
    print(add2(14)) #传入x ， 其他的使用默认值
    print(add2(15,3,5,2))#顺序传参
    print(add2(3,b=5))#传入 x,b 其他的使用默认值


#不定长参数调用
print(add3(1,3,4,6,7,8,11))    
add4(3,a=10,b=12,c=33)

add5(1,2,3,4,5,a=45,b= 222,c=222)

add6()