一、Python基础知识

1.1 变量和字符串

# 格式化输出
str.format()
# 删除空格
str.strip()

查找字符串

方法一：str.find()

方法二：原始串 in 目标串

替换字符

str.replace(原始串,目标串,[替换次数])

字符串处理函数

str.upper() #转大写

str.lower() #转小写

str.capitalize() #首字母转大写

str.title() #每个单词首字母大写

str.swapcase #大小写互换

等值判断(字符串利用字符串处理函数)

print("ABC".lower()=="abc".lower())

print(" abc".strip()=="abc".strip())

Print输出

print( 字符串 )  #换行输出 
print( 字符串,end="" )#不换行输出

举例一

i=0
while i<4:
    print("口",end="") #结尾不换行 口口口口
i=i+1

1.2运算符

算数运算符、比较运算符、逻辑运算符、赋值运算符、成员运算符、身份运算符、位运算符

位运算符:& 与、| 或、^ 亦或、 ~ 取反、<< 左移、>> 右移

a=60 #60的二进制：00111100
b=13 #13的二进制：00001101

print("a & b:",a&b) #00001101 = 12
print("a & b:",a|b) #00111101 = 61
print("a ^ b:",a^b) #00110001 =49
print("~ a:",~a)    #-00111101=-61
#11000011 =195
#首位为1 ，则为负数；为0 则为正数；为1则需要按位取反再+1
#-（~11000011+1）
#-（00111100+1）
#-00111101=-61

print("a << b:",a<<3)  #00111100000 = 480
print("a >> b:",a>>3)  #00000111 = 7

逻辑运算符的优先级：not>and>or

成员运算符和身份运算符

(1)成员运算符

in       返回True/False
not in

(2)身份运算符

is       判断是否同一个对象
is not

1.3流程控制语句

顺序执行、分支语句、循环语句

1.3.1分支语句if基本形式

 if 判断条件:
        执行块
else：
    执行块

举例一

print("欢迎来到***场所")
age=input("请出示你的身份证：")
age=int(age)
if age<18:
    print("你还未满18岁,禁止入内！");
else:
    print("欢迎光临，我们讲竭诚为您服务！");

举例二

weight=input("请输入你的体重（kg）：")
height=input("请输入你的身高（m）：")
#体重/身高的平方 pow(4,2)=16
BMI=int(weight)/pow(float(height),2)
if BMI<=18.4:
    print("您体重的BMI值为：%.2f,体重偏瘦。"%BMI)
elif BMI>=18.5 and BMI<=23.9:
    print("您体重的BMI值为：%.2f,体重正常。"%BMI)
elif BMI>=24.0 and BMI<=27.9:
    print("您体重的BMI值为：%.2f,体重过重。"%BMI)
else:
    print("您体重的BMI值为：%.2f,体重肥胖。"%BMI)

1.3.2循环语句while基本形式

while 判断条件:
     执行块

举例一：阶乘计算,数值1-100，能被5整除即输出。

Y = 1 #结果
i = 1
while 1:
    X=input("请输入1-100的数值:")
    X=int(X)
    if (X<0 or X>100):
        print("您输入的有误，请重新输入！")
    else:break
while i<=X:
    Y=Y*i
    if i%5==0:
        print("{0}!={1}".format(i,Y))
    i=i+1
print("最终结果：{0}!={1}".format(i-1, Y))

*:continue 和 break的使用，一般放在if后面

1.3.3遍历循环基for基本形式

for 迭代变量 in 列表

举例一：输出“赵六”的正索引和负索引

list=['张三', '赵六', '李四', '王五', '赵六', '钱七', '孙八']
i=0         #正索引
j=len(list) #负索引：得到对应总长度*-1
for p in list:
    if p== '赵六':
        print(p,i,j*-1+i) #赵六 1 -6 赵六 4 -3
    i+=1

循环嵌套

举例一：查找1000以内的质数：只能被自身和本身整除的数

j=2
Num=input("请输入区间（大于1的数值）：")
Num=int(Num)
while j<Num:
    is_prime=True
    i=2
    while i<j:
        if j%i==0:
            is_prime=False
            break
         i+=1
     if is_prime:
        print("{0}是质数".format(j))
     j=j+1

1.4内置数据结构

列表、字典、元组、集合

1.4.1列表（List）

变量名=[元素1,元素2,...]

列表的取值

# 取值语法：变量=列表变量[索引值(0-n/-n+1-1)]
list=['张三','李四','王五','赵六','钱七','孙八']
zhaoliu1=list[3]     #正索引
zhaoliu2=list[-3]    #负索引
print(zhaoliu1)    #赵六
print(zhaoliu2)    #赵六

# 范围取值：列表变量=原列表变量[起始索引:结束索引]，左闭右开
list1=list[1:4]
print(list1)  #['李四', '王五', '赵六']

# 列表的index函数用于获取指定元素的索引值
zhangliu_index=list.index('赵六')  # 未有此元素则报错
print(zhangliu_index)  #3
列表的反转与排序

#reverse方法用于反转列表
list = ['张三', '赵六', '李四', '王五', '赵六', '钱七', '孙八']
list.reverse() 
print(list)

#sort()用于排序，默认升序，reverse=True代表降序排列
numbers=[28,32,14,12,53,42]
numbers.sort(reverse=True)
print(Numbers)

举例一：冒泡排序

numbers=[28,32,14,12,53,42]
j=0
len=len(numbers)-1
print("排序前：{0}".format(numbers))
while j < len:
    i=0
    while i < len:
        if numbers[i]>numbers[i+1]:
           a= numbers[i]
           numbers[i]=numbers[i+1]
           numbers[i+1]=a
        i += 1
    len-=1
print("排序后：{0}".format(numbers))

列表的新增、修改、删除操作

list = ['张三', '赵六', '李四', '王五', '赵六', '钱七', '孙八']

list.append(新元素) 在列表末端追加新元素

list.append('杨九')
print(list)#['张三', '赵六', '李四', '王五', '赵六', '钱七', '孙八', '杨九']

list.insert(索引,新元素) 在指定索引插入新元素

list.insert(2,'刘二')
print(list)  #['张三', '赵六', '刘二', '李四', '王五', '赵六', '钱七', '孙八', '杨九']

list[索引]=新值更新指定索引位置数据

list[2]='宋二'
print(list)  #['张三', '赵六', '宋二', '李四', '王五', '赵六', '钱七', '孙八', '杨九']

list[起始索引:结束索引]=新列表更新指定范围数据

list[3:5]=['王五','李四']
print(list)  #['张三', '赵六', '宋二', '王五', '李四', '赵六', '钱七', '孙八', '杨九']

list.remove(元素) 删除指定元素

list.remove('宋二')
print(list)  #['张三', '赵六', '王五', '李四', '赵六', '钱七', '孙八', '杨九']

list.pop(索引) 按索引删除指定元素

list.pop(4)
print(list)  #['张三', '赵六', '王五', '李四', '钱七', '孙八', '杨九']

删除多个区间的元素

list[4:7]=[] 
print(list)  #['张三', '赵六', '王五', '李四']

列表的其它常用方法

list = ['张三', '赵六', '李四', '王五', '赵六', '钱七', '孙八']

统计出现次数

cnt=list.count('赵六')
print(cnt)

追加操作

append将整个列表追加至末尾，extend则是把列表的元素追加至原始列表末尾;

list.append(['杨九','吴十'])
list.extend(['杨九','吴十'])
print(list)#['张三', '赵六', '李四', '王五', '赵六', '钱七', '孙八', ['杨九', '吴十'], '杨九', '吴十']

in(成员运算符) 判断数据是否在列表中

list = ['张三', '赵六', '李四', '王五', '赵六', '钱七', '孙八']
b='张三' in list
print(b)     #True
list.remove('张三')
b='张三' in list
print(b)    #False

copy 函数用于复制列表

list1=list.copy()
print(list1)

is 判断两个变量是否指向同一个内存

print(list1 is list) #False
print(list2 is list) #True

clear 清空列表

list2=list    #list2 和 list在同一空间
list2.clear()
print(list)  #[],
print(list1)  #['赵六', '李四', '王五', '赵六', '钱七', '孙八']
print(list2)  #[]

举例一：嵌套列表

emp_list=[]
while True:
    info=input("请输入用户信息（姓名,年龄,工资）：")
    if info=="":
        print("录入信息结束!!!")
        print("---------------")
        break;
    info_list=info.split(",")#通过逗号分割 ['***', '1', '15000']列表
        if len(info)!=3:
            print("输入的数据有误，请重新输入")
        else:
            emp_list.append(info_list)
 
for emp in emp_list:
    print("姓名：{n} 年龄：{a} 工资：{s}".format(n=emp[0],a=emp[1],s=emp[2]))

1.4.2字典（Dict）

Python中的内置数据结构：键(key)[唯一性]:值(value)

创建{}

dict1={}#空的字典
print(type(dict1)) 
#<class 'dict'>

dict2={'name':'王峰','sex':'男','hiredate':'1997-10-20','grade':'A','job':'销售','aslary':1000,'welfare':100}
print(dict2) 
#{'name': '王峰', 'sex': '男', 'hiredate': '1997-10-20', 'grade': 'A', 'job': '销售', 'aslary': 1000,'welfare': 100}

使用dict函数创建字典

dict3=dict(name='王峰',sex='男')  
print(dict3) #{'name': '王峰', 'sex': '男'}

fromkeys是创造一个新的字典。就是事先造好一个空字典和一个列表，fromkeys会接收两个参数，第一个参数为从外部传入的可迭代对象，会将循环取出元素作为字典的key值，另外一个参数是字典的value值，不写所有的key值所对应的value值均为None，写了则为默认的值

dict4=dict.fromkeys(['name','sex','hiredate','grade'],'N/A')
print(dict4)  #{'name': 'N/A', 'sex': 'N/A', 'hiredate': 'N/A', 'grade': 'N/A'}

字典的取值

dict2={'name':'王峰','sex':'男','hiredate':'1997-10-20','grade':'A','job':'销售','aslary':1000,'welfare':100}
name=dict['name']
print(name) #王峰
print(dict2.get('dept','其它部门'))#有则取对应的值，无则取默认值：其它部门

举例一：遍历字典

#方法一：
for key in dict2:
    v=dict2[key]
    print(v) #返回key的vlues值
#方法二：
for key,value in dict2.items():  #返回每个字典的键值对
    print(key,value)

字典的新增（修改）、删除操作

（1）字典的更新

dict2={'name':'王峰','sex':'男','hiredate':'1997-10-20','grade':'A','job':'销售','aslary':1000,'welfare':100}
#单个kv进行更新
dict2['grade']='B'
print(dict2)
#多个kv进行更新
dict2.update(aslary=1200,welfare=100) 
print(dict2)

字典的新增和更新操作完全相同，有则更新，无则新增的原则

（2）字典删除

#1.pop删除指定的kv
dict2.pop('welfare')

#2.popitem删除最后一个kv
kv=dict2.popitem('welfare')

#3.clear 清空字典
dict2.clear()

字典的其它常用方法

（1）设置默认值

1.setdefault为字典设置默认值，如果某个key已存在则忽略，如果不存在则设置

dict2.setdefault('grade','C')

（2）获取字典的视图

#1.keys 代表获取所有的键
ks=dict2.keys()

#2.values代表获取所有的值
vs=dict2.values()

#3.items代表获取所有的键值对
its=dict2.items()

（3）利用字典格式化字符串

#老版本的字符串格式
emp_str="字段名：%(key)s"%变量

#新版本的字符串格式
emp_str2="字段名：{key}".format_map(变量)

（4）in 成员运算符

print('name' in dict2) #True
print('dept' in dict2) #False

1.4.3散列值（Hash）

生成一个动态的hash值，存放在对应的磁盘中，每一次运行生成都不一样，但是一个程序中显示的都一样：hash()

字典的存储结构，唯一性

在项目中的应用，速度更快

举例一：对用户进行处理，并通过员工号查询对应的员工信息

str='1182,CLARK$5000,YULISA'
user_info=str.split('$')
all_info ={}

for i in range(0,len(user_info)):
    e=user_info[i].split(',')
    info={'number':e[0],'name':e[1]}
    all_info[info['number']]=info

print(all_info)#{'1182': {'number': '1182', 'name': 'CLARK'}, '5000': {'number': '5000', 'name': 'YULISA'}}

number=input("请输入需要查找的员工工号：")
if number not in all_info:
    print("暂无此员工信息！")
else:
    nbr = all_info.get(number) #{'number': '1182', 'name': 'CLARK'}
    print(nbr)

1.4.4元组(Tuple)

元组和列表的区别：

1.“不可变”的列表

2.元组使用小括号，列表使用方括号

创建变量名=('元素1','元素2',...)，也可不带括号

元组读与写

1.读取方式与列表相同

2.元组允许使用“元组运算符”来创建新元组

t=('A','B','C',1,2,3)
print(type(t)) #<class 'tuple'>
print(t[5]) #正序索引，获取第六个元素，3
print(t[-1])  #倒序索引，3
print(t[1:4]) #范围取值：#('B', 'C', 1)
print('B' in  t) #成员运算符

如果元组内持有列表，那么列表的内容是允许被修改的

t2=(['张三',38,5000],['李四',28,2000])
item=t2[0]
item[1]=40
print(t2) #(['张三', 40, 5000], ['李四', 28, 2000])

元组运算符

t3=(1,2,3)+(4,5,6)
print(t3) #(1,2,3,4,5,6)

#元组运算符同样适用于列表
t3=[1,2,3]+[4,5,6]
print(t3) #[1, 2, 3, 4, 5, 6]

#如果元组只有一个元素，则必须在这个元素后增加逗号，说明这是一个元组
t4=('see',)*5
print(t4) #('see', 'see', 'see', 'see', 'see')

1.4.5序列（Sequence）

“有序”的队列,序列包含常用数据结构：字符串（Str）、列表（List）、元组（Tuple）、数字序列（Range）

数字序列（Range）

range(起始值,结束值,[步长])

r1=range(10,20)
r2=range(10,20,2)
print(r1[1]) #11
print(r2[1]) #12
#成员in ，not in 也可以适用

举例一:利用range遍历其它序列

c="ABCDEFG"
for i in range(0,len(c)):
    print(c[i])

举例二：斐波那契数列**** #1,1,2,3,5,8

result=[]
for i in range(0,50):
    if i==0 or i==1:
        result.append(1)
    else:
        result.append(result[i-1]+result[i-2])
 print(result)

举例三：如何判断质数 #只能被1和本身整除的数，1不是

while True:
    x=input("请输入一个整数数值：")
    x=int(x)
    if x<2:
        print("输入有误，请输入大于1的数值")
        continue
    else:
        break
is_prime=True
for i in range(2,x):
    if x%i==0:
        is_prime=False
        break
if is_prime:
    print("数值{X}是质数".format(X=x))
else:
    print("数值{X}能被{i}整除，不是质数".format(X=x,i=i))

序列类型的互相装换

l1=['A','B','C'] #list
t1=('D','E','F') #tuple
S1='ABC123'    #字符串
S2='ABC,123'   #字符串
R1=range(1,4)   #序列

#（1）list()-转为列表
print(list(t1))#['D', 'E', 'F']
print(list(S1))#['A', 'B', 'C', '1', '2', '3']
print(S2.split(','))#['ABC', '123']
print(list(R1)) #[1, 2, 3]

#（2）tuple()-转为元组
print(tuple(l1))  #('A', 'B', 'C')
print(tuple(S1))  #('A', 'B', 'C', '1', '2', '3')
print(tuple(S2.split(','))) #('ABC', '123')
print(tuple(R1)) #(1, 2, 3)

#（3）str()函数用于将单个数据转为字符串，join对列表进行连接
    #join必须要求所有元素都是字符串
print(str(l1)) #['A', 'B', 'C']
print("".join(l1)) #ABC
print("，".join(l1)) #A，B，C

1.4.6集合（Set）

集合：无序的、元素不能重复、可变的、允许数学运算

集合是分散存储的

集合的创建

(1)使用{}

college1={'语文','数学','英语'}
print(college1) #输出的结果每次不同

(2)使用set()

college2=set(['语文','数学','英语'])
print(college2) #输出的结果每次不同

#使用set 创建字符串集合
college3=set('中华人民共和国')
print(college3) #{'中', '华', '人', '和', '民', '国', '共'}
# college4={} <class 'dict'> 会看为一个字典
college4=set()
print(type(college4))  #<class 'set'>

集合的数学运算

（1）交集（intersection）

college1={'语文','数学','英语','体育'}
college2=set(['语文','数学','英语','历史'])
c3=college1.intersection(college2) #产生一个新集合
college1.intersection_update(college2) #更新原有的集合
print(c3)

（2）并集（union）

c4=college1.union(college2)
print(c4)

（3）差集（difference）

college1={'语文','数学','英语','体育'}
college2=set(['语文','数学','英语','历史'])
c5=college1.difference(college2)
print(c5)

#symmetric_difference代表双向差集
c6=college1.symmetric_difference(college2) #{'历史', '体育'}
print(c6)

#symmetric_difference代表双向差集更新至原有的集合
college1.symmetric_difference_update(college2)
print(college1)

集合的关系操作

== 判断两个集合元素是否完全相同

集合A.issubset(集合B) 判断A是否为B子集

集合A.issuperset(集合B) 判断A是否为B父集

集合A.isdisjoint(集合B) 判断两个集合是否有重复的值，True代表不存在重复元素，Flase则代表存在重复

操作集合元素（增删改查）

（1）遍历

college1={'语文','数学','英语','体育'}
for i in college1:
  print(i)


#集合不支持按索引提取数据

（2）判断一个元素是否在集合中

print('语文' in college1)

（3）新增

#新增单个数据 :add无则添加，有则不变，同时一次性只能更新一个
college1.add("计算机")
#新增多个数据
college1.update(['音乐','自然'])

（4）修改/输出

更新数据是要删除原有元素，再创建新元素；remove删除不存在的元素，会报错

discard如果遇到不存在的元素是，则会忽略删除操作

college1.remove("自然")  #删除元素
college1.add("科学")
college2.discard("自然")

1.4.7生成式（List Comprehensions）

语法：[被追加的数据循环语句循环或者判断语句]|{}

列表生成式

#原语句：
lst1=[]
for i in  range(10,20):
    lst1.append(i*10)
print(lst1) 

#生成式：
list2=[i*10 for i in range(10,20)]
print(list2) #[100, 110, 120, 130, 140, 150, 160, 170, 180, 190]
#原语句：
lst3=[]
    for i in  range(10,20):
        if  i%2==0:
            lst3.append(i*10)
print(lst3)

#生成式：
lst4=[i*10 for i in range(10,20) if i%2==0]
#print(lst4) #[100, 120, 140, 160, 180]
#原语句：
lst5=[]
    for i in  range(1,5):
        for i in range(1,5):
             lst5.append(i)
print(lst5) 

#生成式：
lst6=[i for i in range(1,5) for i in range(1,5)]
print(lst6) #[1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4]

字典生成式

#原语句：
lst7=['张三','李四','王五']
dict2={}
for i in  range(0,3):
    dict2[i+1]=lst7[i]
print(dict2)

#生成式：
lst7=['张三','李四','王五']
dict1={i+1:lst7[i] for  i in range(0,len(lst7)) }
print(dict1) #{1: '张三', 2: '李四', 3: '王五'}

集合生成式

#原语句：
for i in range(1,4) :
    for j in range(1,4) :
        if i==j:
            set1.add(i*j)
print(set1)

#生成式：
set1={i*j for i in range(1,4) for j in range(1,4) if i==j}
print(set1) #{1, 4, 9}

posted @ 2020-08-24 18:04 Yulisa 阅读(245) 评论(0) 收藏举报

刷新页面返回顶部

Yulisa