python基本语法一

#数据类型
a = 1.5
print(a)
a, b = 3, 4.5
a, b = b, a + b
print(a, b)
c = 1.0
print(type(c))
c = False
print(type(c))
#转义
a = 6
b = float(a)
print(type(b))

#不可变对象：在同一对象内，不能删除， 不能增加，不能替换
#序列, 不可变对象
#序列内部元素不可改变， 不能被替换和删除， 只能新增一个新序列取代要改的序列
#python没有字符串
#支持切片操作，访问长度-1， 越界就报错
text = "abcdf"
print(text[0:3])   #截取前三位：abc
print(text[1:5]) #bcdf
print(text[-3])
print(text[-2])  #倒数第二个 d
print(text[-3:-1]) #cd
print(text[::-1])  #fdcba
print(text[::-3]) #fb
print(text[::2]) #fb

#turple 元组
#支持切片， 不可变对象，不能做替换和删除， 不可通过索引赋值
#可以存复合型内容，可支持所有类型
#创建元祖时，只有一个元素注意加豆号
a = (2, 3)
print(a)
b = (2, )   #(2,)
print(b)  #一个元素加豆号

#byte --- 不可变对象
a = b'abc'
print(type(a))  #<class 'bytes'>

#list --- 可变对象
#可变对象：可增加， 可修改， 可删除
#list 支持复合类型, 类似数组, 常用

a = ['a', 'b', 'c', '5', (3, 4, 'nihao'), 'hahaha']
b = a[-2]
print(b[-1])  #nihao
print(a[-2][-1])  #nihao
print(a[-2][-1][:2])  #ni
print(a)     #['a', 'b', 'c', '5', (3, 4, 'nihao'), 'hahaha']
print(type(a))  #<class 'list'>

#set ---集合
#不会有重复，不止比较类型，如果值相同会被去重
#可变对象。无序结构， 无索引概念， 可以被迭代，支持len()
#作用：去重， 交集并集，
#代表一个可变集， 用Set()创建，add(), remove()修改
#虽然是复合型数据结构，但不能存放可变对象， 尽量放整型
b = set()
print(type(b))   #<class 'set'>
a = {'abc', 1, 2}
print(a)      #{'abc', 1, 2}
w = {'banana', 'apple', 'apple', 'orange'}
print(w)  #{'apple', 'banana', 'orange'}
w1 = {'peanut', 'milk', 'water', 'milk'}
print(w | w1)
print(type(a))

#mapping 任意索引集， 可变对象
#dict, 字典

#健值对， 一一对应， Key---value
#val 可变， key -- 不可变
a = {1: 'abc', 1.0: 'edf'}
print(a)  #{1: 'eddf'}
b = dict()
b['abc'] = 1000
print(b) #{'abc': 1000}

#运算符

#布尔运算
#or, and, not 同 ||， &&， ！
x = 3
print(x > 10 and x % 2 != 1)  #False
a = 1
b = 4
print(not a == b)  #True, ==的优先级高于not

#比较运算
up = 10
down = 7
x = 3
print(down < x < up)  #False, 可以连续运算
print(down < x and x < up)
a = 2
b = 5
print(a is b)  #False
print(id(a), id(b)) #140705940903616 140705940903712
#is 比较值 和 id
a = 8
b = 2
print(a ** b)  #64
print(a // b)  #4
print(a / b)  #4.0

#流程控制 - 条件语句
# if:
# else:

a = 2
if a % 2 == 0:
    print('偶数')
else:
    print('奇数')  #偶数

#循环结构 -- while(), 没有 do while()

i = 1
sum = 0
limit = 10000
cnt = 100
while i <= cnt:
    if sum + i > limit:
        print(sum)
        print(i)
        break
    sum += i
    i += 1
else:   #干扰退出， while 条件不满足不正常退出后执行这条语句
    print(sum)  #5050
    print(i)   #101

#循环结构 --- for, 是一个迭代列表或序列
a = [1, 2, 4, 'a', 7]
for item in a:
    print(type(item))

#range 用来遍历数字序列
for i in range(10):
    print(i)    #打印0 - 9
r = range(10)
print(r)    #range(0, 10)
a = ['a', 1, 'f']
for i in range(len(a)):
    print(a[i])
for i in range(10, 0, -1):
    print(i)   # 打印 10 - 1， 0取不到

#迭代器与生成器
#迭代器， 是对象， 是可以记住遍历位置的对象， 从集合的第一个元素访问， 访问结束后正常报错
#方向只能往前， 不能回退
#基本方法 iter, next
a = [1, 3, 4, 6, 8]
it = iter(a) # it 就成了迭代对象
print(it)  #<list_iterator object at 0x00000173B36F87F0>， 说明是个对象
print(next(it))  #第一次打印1， 之后一次递增
print(next(it))  # 3
for i in it:
    print(i)  #for 循环中全部打印完后， 不报错

#生成器， 返回一个迭代器的函数，就是生成一个迭代器
#调用生成器时， 遇到yield函数会暂停并保存当前信息， 反悔yield的值， 在下一次执行next()时从当前位置继续执行
def feibo(n):
    a, b = 0, 1
    cnt = 0
    while cnt <= n:
        a, b = b, a + b
        yield(a)    #生成迭代器
        cnt += 1
f = feibo(10)   #f 为可迭代对象
for i in f:
    #print(i)    #遍历生成的迭代器


#函数 def，关键字
#def max(a, b), return 关键字设置返回值
    def Hell():
        print('hello world')
Hell()

def m_max(a, b):
    if a > b:
        return a
    else:
        return b
a, b = 3, 5
print(m_max(a, b))
#函数中参数传递
#不可变对象参数
def change(a):
    print('传入的数的 id : ', id(a))
    a = 10
    print('赋值后的 id:', id(a))
ab = 9
print('调用前 id :', id(ab))       #调用前 id : 140706281625504
change(ab)        #传入的数的 id :  140706281625504    赋值后的 id: 140706281625536
print('调用后的 id :', id(ab))  #调用后的 id : 140706281625504
#不可变对象传入后不受函数控制， 函数内部操作无法改变不可变对象
#、可变对象传参
def change_list(mylist):
    mylist.append(['a', '3', 'v'])
    print('函数内部', m_list)   #函数内部 [['a', '3', 'v']]
    print('函数内部 id ', id(m_list))
    return
m_list = []
print('函数外部 ', m_list)     #函数外部  []
change_list(m_list)
print('函数外部调用结束  ', m_list)  #函数外部调用结束   [['a', '3', 'v']]
print('函数外部  id', id(m_list))  #函数外部  id 1821360194624
#可变对象函数内外一致， 可被函数内部改变

#必须参数

def  func(str1, str2):
    print(str1, str2)
    return
func('abc', 'def')   #abc def

def my_print(name, age):
    print('年龄 ：', age)
    print('姓名 ：', name)
    return
my_print('李四', 38)   #年龄 ： 38  姓名 ： 李四
#关键字参数使用
my_print(name = '王二', age = 19)  #年龄 ： 19   姓名 ： 王二

def my_printplus(name, age, cmp = 'mmm'):
    print('年龄 ：', age)
    print('姓名 ：', name)
    print('单位 ：', cmp)
    return
my_printplus('lisi', 45)  #年龄 ： 45 姓名 ： lisi  单位 ： mmm

#不定长参数
def func_print(arg1, *virtuple):
    print('输出 ')
    print(arg1)
    print(virtuple)
    print(type(virtuple))  #<class 'tuple'>, 是元组类型， 可一一遍历
    return
func_print(10, 12, 1234, 34, 45)   #(12, 1234, 34, 45)

def func_print2(arg2, **var):
    print('输出')
    print(arg2)
    print(var)
    print(type(var))
    return
func_print2(10, a = 12, b = 99, c = 89) # 传参需要有key 值， 返回也是 字典
'''
输出
10
{'a': 12, 'b': 99, 'c': 89}
<class 'dict'>
'''

#匿名函数 Lambda
def get_sum(a, b):
    return a + b
lam_sum = lambda a, b: a + b
num1 = 20
num2 = 30
print('函数计算值 ：', get_sum(num1, num2))
print('lambda 计算 ：', lam_sum(num1, num2))
'''
函数计算值 ： 50
lambda 计算 ： 50
lambda 可看作一个一次性函数，用完就被释放了
'''

#文件-- open()
#file -- 必须参数， mode -- 可选， 打开模式
f = open('text.txt', mode='w', encoding='utf-8')
f.write('hello world\npython is very good\nwe all study it')
f.close()

f = open('text.txt', mode='r', encoding='utf-8')
str = f.readline()  #readline() 按行读， 需要循环， read()一次性全部读完
f.close()
print(type(str))
print(str)
#readlines(), 读完全部行
#文件对象本身可以作为迭代对象
f = open('text.txt', mode='r', encoding='utf-8')
for data in f:
    print(data, end = '')
f.close()
#字典和元祖需要强转为字符串