python基础语法要点

一 python脚本

交互编译环境

>>>

python的脚本或者程序

编写python程序的文件；后缀是.py

二变量：

就是一个英文字符来记录或标记一些数据，并且这个被标记的数据是可以变化的。

定义时注意

1，变量名可以使用数字，字母，下划线；

2，不能以数字开头；

3，严格区分大小写；

4，不要使用中文；

5，不要使用系统关键字。

6，变量命名规范适用于脚本名称和后期的函数名及其他命令规范。

变量定义方式

第一种

a = 10
b = 20
print(a,b)

第二种

a,b = 10,20
print(a,b)

变量数据交换

第一种

a = 10
b = 20

#交换变量，赋予给第三个方

c = a#定义变量c,接收变量a的值，此时c变量的值是10
a = b#把b变量的值赋予给a，此时a变量的值就是20
b = c#把c变量的值赋予给b，此时b变量的值就是10
print(a,b)

第二种

a = 10
b = 20

#利用python定义变量的语法来实现

a,b = b,a

print(a,b)

三数据类型—数据的表现形式

1.字符串

#使用引号定义的字符串可以嵌套别的字符串,单可以嵌双，双可以嵌单，单不能嵌单。
str1 = 'hahhah "lalla" hahahah'

str2 = '''
        哈哈哈'hahhahhh'llall，
        "啦。。。。啦。。。。啦。"
        可"""以换行"""呢。
        '''#大字符串
str3 = '不可以换行' #字符串

type( )函数—获取当前变量/数据的数据类型

 print(str1,type(str1))
  #或者
 res = type(str1)
 print(str1,res)

转义字符：

\n —表示换行

\t —表示一个制表符

str4 = '啦啦啦\n啦啦啦啦'
        
print(str4)     #输出：啦啦啦
                        #           啦啦啦啦
        
  
str5 = r'啦啦啦\n啦啦啦啦'#前面添加r，可以取消转义字符。
        
print(str5)     #输出：啦啦啦\n啦啦啦啦

2.数字类型（Number）—可以运算

a = 123 #int
b = -123 #int
c = 3.1415926 #float
d = 0x10 #十六进制 #转成 int
e = 1+2j #complex
f = True #bool ;1
g = False #bool;0

3.列表—表示一系列或者一组数据 [ ]

当定义多个数据内容时

#在需要进行多个数据时，可以使用中括号进行定义

#每个数据之间使用逗号进行分隔
list1 = [123,145,167,89]
print(list1,type(list1))#<class 'list'>

#列表中存储的数据可以是任意类型，列表中存储的每一组数据称为元素
list2 = ['a',123,'啦啦啦','3.1415']

#可以通过下标获取
print(list2[0]) #a
print(list2[-2]) #啦啦啦

#列表中元素的元素可以存储一个列表,called二维列表or多维列表
list3 = [123,[234,345,456],78,'abc']
print(list3[1]) #[234,345,456]
print(list3[1][2]) #456

4.元祖—和列表像，用于存储多个数据时使用 ( )

当定义多个数据内容时

tuple1 = (1,2,3,'a',3.1415)
print(tuple1,type(tuple1)) #<class,'tuple'>
print(tuple1[3]) #a

#注意：定义元祖时，括号就一个元素需要加逗号
mo = (123) #int
mn = ('abc') #str
ml = (123,) #tuple
mk = ('abc',) #tuple

#区分：值和数量不对应
va,vb = 1,2 #变量定义
vc = 1,2,3 #元祖定义 print(vc,type(vc))  #(1,2,3)<class 'tuple'>

列表和元祖的区别：
- 列表用 [ ] 定义，元祖用( )定义
- 列表中的值可以被改变，元祖中的值不可以被改变

list5 = [1,2,3]
list5[1] = 44
print(list5) #[1,44,3]

tuple5 = (1,2,3)
tuple5[1] = 44
print(tuple5) #报错

5.字典—用于存储一组或者多组数据，是键值对的存储方式,e.g.数据库，爬虫时存储数据

dict1={key1:value1,key2:value2,...}
键—必须字符串或者数字，键名不可以重复，否则后面的会覆盖前面的
值—可以是任意类型，值可以重复
特点：python之前的版本中，字典是无序的（其实现在也是无序的，但是展示的时候是有序的）

#比如记录一本书的相关数据，书名，作者，价格。。。
dict1 = {'title':'《龙族》','auther':'江南','price':'75'}

print(dict1,type(dict1))#{'title':'《龙族》','auther':'江南','price':'75'} <class 'dict'>

print(dict1['title']) #《龙族 》

6.集合

特点：无序且元素不重复的 集合数据类型;如果出现重复元素就去重，保留一个
怎么定义：用 { } 或者 set( ) 定义

#集合的定义方式1
set1 = {1,2,54,'lh','wyf'}
print(set1,type(set1)) #<class 'set'>

#集合的定义方式2
set2 = set('12334556')#set
print(set2)#{'4', '2', '6', '5', '3', '1'} 
        #注意：
set_m = set(123456)#'int' object is not iterable

#当需要定义一个空集合时，只能使用set(),因为{}会定义成空字典
set3 = set()#空集合
set4 = set('')#空集合

#集合可以做什么？？？
set1 = {1,2,54,'lh','wyf'}

#无法获取集合中的单个元素，但是可以添加(add)和删除(remove,doiscard)
set1.add('pcy') #print(set1) {1, 2, 'pcy', 'wyf', 54, 'lh'}
set1.remove(1) #print(set1) {2, 'pcy', 'wyf', 54, 'lh'}
set1.discard('lh') #print(set1) {2, 'pcy', 'wyf', 54}

#检查当前元素是否在集合中
print(1 in set1) #False
print('pcy' in set1) #True

#集合的作用：主要用于运算，交集，差集，并集，对称集合
set2 = {1,2,3,'a','b'}
set3 = {1,'a',22,33}

print(set2 & set3)#求交集 {1,'a'}
print(set2 - set3)#求差集，set2有set3没有 {'b',2,3}
print(set3 - set2)#求差集，set3有set2没有 {22,33}
print(set2 | set3)#求并集，即去重 {1, 2, 3, 33, 'b', 22, 'a'}
print(set2 ^ set3)#求对称差集,即并减交{33, 2, 3, 'b', 22}

四基础数据类型转换

1.数据类型总结

不可变数据类型（指内容不可变）

字符串 string 【容器类型】

数字 number 【非容器类型】

整型 — int

浮点 — float

复数 — complex

布尔 — bool 【非容器类型】

元祖 tuple 【容器类型】

可变数据类型（指内容不可变）

列表 list 【容器类型】

字典 dict 【容器类型】

集合 set 【容器类型】

2.什么是数据类型转换？

把一个数据类型转换为另一个数据转换

字符串转换为数字

3.为什么需要数据类型转换？

因为数据类型之间不能运算

4.转换的形式？

自动类型转换

#和数字进行计算时，True转为数字1，False转为数字0
a = 123
b = True
c = False
print(a+b)#124
print(a+c)#123

#if判断
if True:
        print('真')
else:
        print('假')
    
#当两个不同的值进行运算时，结果向更高的精度进行计算
True ==> 整型 ==> 浮点 ==> 复数

强制类型转换

#几个函数
str()#可以把其他类型的数据转换字符串

int()#字符串中纯数字，可以转换成数字；其他容器类型不能转换为数字类型
float()#同int,转换 结果是浮点

bool()#可以把其他类型的数据转换为布尔类型的True或False
'''
总结：
True    ————字符串里有个0：bool('0')

False   ————空字符串：bool('')
False   ————数字0：bool(0)
False   ————浮点0.0：bool(0.0)
False   ————空列表：bool([])
False   ————空字典：bool(dict())or bool({})
False   ————空集合：bool(set())
False   ————空元祖：bool(())
'''

容器类型转换

list()
#字符串 可以转换为 列表：把字符串中每一个字符都当作列表元素
a = '123'
res = list(a)
print(a,type(a))#'123' <class 'str'> 
print(res,type(res))#['1','2','3'] <class 'list'>

#数字 不可以转换为 列表：因为数字类型非容器类型
b = 123
res = list(b)
print(b,type(b))#123 <class 'int'> 
print(res,type(res))#报错 'int' object is not interable

#集合 可以转换为 列表：把{}换成[]
c = {'a','b',1,'c'}
res = list(c)
print(c,type(c))#{'b',1,'c','a'} <class 'set'> 
print(res,type(res))#['b',1,'c','a'] <class 'list'>  

#元祖 可以转换为 列表：把()换成[]
d = (1,2,3)
res = list(d)
print(d,type(d))#(1,2,3) <class 'tuple'> 
print(res,type(res))#[1,2,3] <class 'list'> 

#字典 可以转换为 列表：把{}换成[],只保留key
e = {'title':'龙族','price':75}
res = list(e)
print(e,type(e))#{'title':'龙族','price':75} <class 'dict'> 
print(res,type(res))#['title','price'] <class 'list'>

tuple()
#数字 不可以转换为 元祖：因为数字类型非容器类型

#字符串 可以转换为 元祖：把字符串中每一个字符都当作元祖元素
f = '123abc'
res = tuple(f)
print(f,type(f))#123abc <class 'str'> 
print(res,type(res))#('1','2','3','a','b','c') <class 'tuple'> 

#列表 可以转换为 元祖：把[]换成()
g = [123]
res = tuple(g)
print(g,type(g))#[123] <class 'list'> 
print(res,type(res))#(123,) <class 'tuple'> 

#集合 可以转换为 元祖：把{}换成()
h = {123}
res = tuple(h)
print(h,type(h))#{123} <class 'set'> 
print(res,type(res))#(123,) <class 'tuple'> 

#字典 可以转换为 元祖：把{}换成(),只保留key
I = {'title':'龙族','price':75}
res = tuple(I)
print(I,type(I))#{'title':'龙族','price':75} <class 'dict'> 
print(res,type(res))#('title','price') <class 'tuple'>

dict()
#数字 不可转换为 字典：因为数字类型非容器类型        

#字符串 不可转换为 字典

#二级列表并且每个二级列表只有两个元素 可以转换为字典
n = [[1,2],['a','b'],['11',11]]
res = dict(n)
print(res,type(res))#{1:2,'a':'b','11':11} <class 'dict'>

#二级元祖并且每个二级元祖只有两个元素 可以转换为字典
p = ((1,2),(3,4))
res = dict(p)
print(res,type(res))#{1:2,3:4} <class 'dict'>

#集合 不可转换为 字典

运算符

算数运算符：

a = 9
b = 2

a + b = 11
a - b = 7
a * b = 18
a / b = 4.5
a % b = 1
a // b = 4
a ** b = 81

字符串运算符

#1.字符串不能与数字进行计算
  
#2.字符串 + 字符串 ——拼接
print('1' + '2')#12

#3.字符串 * 数字 ——重复出现
print('2' * 6)#222222

#4.字符串拼接
#方法1
m = 'lalala'
n = 'hahh '+m+' 哈哈哈'

#方法2
m = 'lalala'
n = f'hahh {m} 哈哈哈'

#方法3——格式化
m = 'lalala'
n = 'hahh {} 哈哈哈'.format(m)
#n = 'hahh {m} 哈哈哈'.format(m=m)

赋值运算符

a = 666
a += 20
a -= 20
a *= 20
a /= 20
a %= 20
a //= 20
a **= 20
print(a)

比较运算符——表判断

a = '666'
b = 888

print(a == b)
print(a != b)
 
c = 666
d = 888

print(c > d)
print(c >= d)
print(c < d)
print(c <= d)

逻辑运算符—— and or not

#and
#全为真，返回后面的真
#有一个假，就返回假,0
a = true1
b = true2
print(a and b)#true2
print(10 and 30)#30
print(60 and 20)#20
print(10 and 0)#0
print(0 and 40)#0

#or
#有真则真，全假则假
print(True or False)#True
print(False or False)#False
print(10 or 50)#10
print(30 or 0)#30
print(0 or 50)#50

#not
print(not True)#False

二进制

bin( )函数

print(bin(125))#0b1111101

十进制转二进制

除二取余，逆序排列

#125转为二进制
print(125//2,125%2)#125 / 2 = 62...1
print(62//2,62%2)#62 / 2 = 31...0
print(31//2,31%2)#31 / 2 = 15...1
print(15//2,15%2)#15 / 2 = 7...1
print(7//2,7%2)#7 / 2 = 3...1
print(3//2,3%2)#3 / 2 = 1...1
print(1//2,1%2)#1 / 2 = 0...1
#把余数从地位到高位依次排列
#1111101

二进制转十进制

按权展开求和

int( )

#1111101转十进制
#1*2**6 + 1*2**5 + 1*2**4 + 1*2**3 +1*2**2 + 0*2**1 + 1*2**0 = 125
print(int(ob1111101))#12

位运算

#&——按位与运算符：参与运算的两个值，如果两个相应位都为1，则该位的结果为1，否则为0

#｜——按位或运算符：参与运算的两个值，如果两个相应位有一个为1，则该位的结果为1。

#^ ——按位异或运算符：当对应的二进制，相异时，结果为1，相同时为0.

其他运算符

#成员运算符 in 与 not in
s = 'lallallall'
m = ['lalla','lal','yih']
n =('lal','kakak')
l = {'lalla','kakk','jiajaijai'}
print('mammam' in s)
#字典类型只能检测key

#身份运算符 is和is not——判断两个变量是否引用同一个对象
a = 5
b = 5
print(a is b)

id()#获取对象的内存地址
== #用于判断引用变量的值是否相等

运算符的优先级(==>表示优于)

** ==> 一元加减号 ==> * / % // ==>加减法 ==> 左移，右移 ==>& ==>^ | ==> 小于，大于，小于等于，大于等于 ==> == != ==> 赋值运算符 ==> 身份运算符 ==> 成员运算符==> 逻辑运算符

流程控制

流程：计算机的执行顺序

1.分支结构

单向分支—如果判断表达式结果成立，就要执行代码区间；不成立，则不执行代码区间。

#做一个判断，走不走这个区间
pre = 10
varity = True

#判断是否有变化
if varity:#判断成立
  pre = 1
 
print(pre)

双向分支—表达式成立则执行真区间；不成立执行假区间

wyf = '吴亦凡'

if wyf == '吴亦凡':
  #真区间
  print('hello')
else:
  #假区间
  print('byebye')

多向分支

weight = 110
if weight >= 100 and weight< 130:
  print('不胖')
elif weight >=90 and weight< 100:
  print('真的不胖')
elif weight >= 80 and weight< 90:
  print('太瘦了，多吃点')
else:
  print('看心情')

巢状分支—在分支条件中，嵌套三层或者五层就行

age = 26
height =184
gender = '男'

if gender == '男':
  print('对，再猜')
  if age >= 25 and age <= 30:
    print('快了，再猜')
    if height >= 180 and height <= 187:
      print('没错，就是吴世勋')
else:
  print('EXO-L')

练习题：输入年份，判断生肖

#申猴 酉鸡 戌狗 亥猪 子鼠 丑牛 寅虎 卯兔 辰龙 巳蛇 午马 未羊
# 0     1        2      3       4       5       6       7       8        9   10   11
#                           2019    2020                        2000                            
#对12取余，找对应

year = int(input('输入四位数字年份： '))
if year % 12 == 0:
    print('{year}年是：申猴'.format(year=year))
elif year % 12 == 1:
    print('{year}年是：酉鸡'.format(year=year))
elif year % 12 == 2:
    print('{year}年是：戌狗'.format(year=year))
elif year % 12 == 3:
    print('{year}年是：亥猪'.format(year=year))
elif year % 12 == 4:
    print('{year}年是：子鼠'.format(year=year))
elif year % 12 == 5:
    print('{year}年是：丑牛'.format(year=year))
elif year % 12 == 6:
    print('{year}年是：寅虎'.format(year=year))
elif year % 12 == 7:
    print('{year}年是：卯兔'.format(year=year))
elif year % 12 == 8:
    print('{year}年是：辰龙'.format(year=year))
elif year % 12 == 9:
    print('{year}年是：巳蛇'.format(year=year))
elif year % 12 == 10:
    print('{year}年是：午马'.format(year=year))
elif year % 12 == 11:
    print('{year}年是：未羊'.format(year=year))
else:
    print('错啦')
    
 #简洁版
year = int(input('输入四位数字年份： '))
m =year % 12
shengxiao = ['申猴', '酉鸡' ,'戌狗' ,'亥猪' ,'子鼠', '丑牛', '寅虎', '卯兔' ,'辰龙', '巳蛇', '午马', '未羊']
print(shengxiao[m])#输出对应下标

tips：1，先想逻辑

2，再优化简洁

2.循环结构

for循环—用于遍历一个容器类型的数据

str1 = '123456789'
str2 = 'sdfdhvojs'
str3 = [1,2,3,4,5]
for i in str1:
  print(i)#当前容器类型的数据
  
for j in str2:
  print(j)

#range()-返回一个可迭代对象的函数
for k in range(1,10):
  print(k)

1，break语句—跳出循环

m = 1
while m < 10:
  m += 1
  if m % 2 == 0:#判断是否为偶数
    continue#跳过本次循环，执行下一次
  else:
    print(m)
  
  if m == 7:
    break#跳出循环，后面不再执行，结束循环

2，pass语句—占位符

3，continue语句—跳过本次循环

4，exit()和quit()—用于结束当前程序

5，break和continue—用来控制程序

while循环—判断当前语句是否成立

While 条件表达式

#定义变量
m = 3
while m <= 10:#判断条件是否成立
  print(m)#输出
  m += 1#更改变量，朝着循环结束的方向前进

练习题：循环输出

num = 0
while num < 100:
    print('✨',end = ' ')
    print(num % 10 ,end = '')#看取余的情况
    #判断是否换行
    if num % 10 == 9:
        print()#换行
    num += 1
    
#隔行变换
num = 0
while num < 100:
    #print('✨',end = ' ')
    #print(num // 10 % 2 ,end = '')#看取余的情况
    #判断奇偶数
    if num // 10 % 2 == 0:
        print('🪐',end = ' ')
    else:
        print('✨',end = ' ')
    #判断是否换行
    if num % 10 == 9:
        print()#换行
    num += 1
    
 #隔列变换
num = 1
while num < 101:
    #print('✨',end = ' ')
    #print(num % 2 ,end = '')#看取余的情况
    #判断奇数还是偶数
    if num % 2 == 0:
        print('*  ',end = ' ')
    else:
        print('✨ ',end = ' ')
    #判断是否换行
    if num % 10 == 0:
        print()#换行
    num += 1