一. 注释
#python e:\py1\01.py
#python e:\Studypython\py2\01.py
print("444444444444444444444444444444444444444444444444444444444444444444444444444"
# 单行注释
'''
这是多行注释
'''
二. print()输出
#打印到屏幕上的一些信息 课题接受多个字符串
#用逗号分隔 遇到逗号会输出一个空格
#可以输出数字
#还可以运算
print("mysql name lickr , onckie function")
print(4+2)
print(8)
print("4+2=",6)
#print ()是输出函数
三. input 交互 数据转换
# input
# 作用输入(阻塞)输入的内容保存在age
# int integer = 整数 把字符串转成int 用int(被转的数据)
# str string = 字符串 把数据转换成i字符串 用str(被转的数据)
# 注意 input 接受的所有数据都是字符串 即便你输入的数字 但是依然会当做字符串来处理
age=input("请输入你的年龄:")
print("age=",age)
四. python :以下是数据类型
number(数字)
整数
浮点数
复数
string(字符串)
布尔值(true/false)
none(空值)
list(列表)
tuple(元组)
dict(字典)
set(集合)
五. 标识字符
标识符(变量) : 是字符串(注意:字符串未必是标识符)
规则: 只能又数字字母下划线线组成
不能数字开头
不能使用python的关键字
区分大小写
见名知意
不能以数字开头
保留字符不能被使用的
变量名不能以大写英文字开头
在python 里不区分 变量(var)和常量 (const)
在python 所有都是可变的量
在python 中所有用全部大写的变量名来代表次变量为常量
作用: 给变量 函数等命名的
注意: 在python3中 非ascll标识符也是允许的 支持万国码 utf-8 undcode
在哪python 2.0以上打印中文 必须加上u 和字符集声明 在2.0 到2.9的版本只支持 Assic 默认编码
六. 变量与常量
程序是之上而下执行:
变量(var): 程序可以操作的存储空间
程序在运行期间可以改变的数据
每个变量都特定的类型
作用: 将不同的数据存储在内存中
列如: age=10
数据的存储 : 变量名=数据值
注意:变量必须先定义在使用
删除变量: del 变量名
删除后变量不能引用了
type() 查看数据类型
name=22
print(type(name)) 查看name数据类型
print(id(name)) 查看变量的地址
常量(const): 数据在运行的时候不能改变的量
在python 中所有用全部大写的变量名来代表次变量为常量
七. number 数据类型
# 分类 :整数 浮点数 复数
# 整数在python中可以处理任意大小的数字 在程序中和数学写法一样
# 单个定义变量
num22=10
num23=num22
# 连续定义多个变量
num=num1=num2=10
print(num,num1,num2)
#查看变量的地址
print(id(num1))
# 交互式赋值定义变量
num8,num9=6,7
print(num8,num9)
# 浮点数:由整数和小数部分组成 浮点数可以四舍五入
a=1.22
b=2.222
# 复数: 实数和虚数组成
a+bj
八. 数字类型转换
print(int(1.9)) # 1 将1.9浮点数转成整数1
print(float(1)) #1.0 将整数1转换成浮点数1.0
print(int("123")) #123 将字符串"123"转换成整数123
print(float("12.22")) #12.22 将字符串"12.22"转换成浮点数12.22
print(int("+123")) #123 注意: 正负号只能放在前面
print(int("-123")) #-123 如果有其他字符会报错
九. 数学功能函数
a=-100
a2=abs(a) #求绝对值
print(a2) #100
#比较两个数大小
b=100 #如果前面b>c 返回1 b<c返回-1 相等返回0
c=20
print((b>c)-(b<c)) #1
print(max(b,c)) #100 给定的参数返回最大的值
print(min(b,c)) # 20 给定的参数返回最xiao的值
#求x的5次方 2^5
print(pow(2,5)) #32 pow()求某某的n次方
#四舍五入round(x,[,n]) 返回浮点数x的四舍五入的值 如果给n值 则代表舍入到小
print(round(3.456)) #3
print(round(3.7)) #4
print(round(3.72228,2)) #3.72 后面那个参数表示保留几位
print(round(3.546,1)) #3.5 后面那个参数表示保留几位
#导入库
#库:封装了一些功能
#import math 意思就是导入数学相关的库
#math 数学相关的库
import math #意思就是导入数学相关的库
向上取整
print(math.ceil(17.9)) #18
print(math.ceil(17.1)) #18
向下取整
print(math.floor(17.9)) #17
print(math.floor(17.1)) #17
返回整数部分 和小数部分
print(math.modf(22.55555)) #(0.5555500000000002, 22.0)
print(math.sqrt(25)) # 5.0#开平方
import random #引入随机数模块
#随机数
print(random.choice([1,2,3,4,5,6])) #表示随机qu一个数组里面的数
#意思重数列中随机取一个
print(random.choice(range(5))) #意思生成1到5的数字
print(random.choice("ABCDEF")) #表示随机取一个数组里面的字母
#生产一个一到10的随机数
sui=random.choice(range(10))+1
print(sui)
# 从指定范围，按指定的奇数递增的集合中选取一个随机数
# random([start,],stop[,step])
# start 指定范围的开始值 包含在范围内
# stop 指定范围的结束值 不包含在范围内
# step 指定的基数
print(random.randrange(1,100,2)) #一到100的奇数 但是不包含一
print(random.randrange(100)) # 从0到100 取一个随机数 但是不包含100
print(random.random()) #生产0到1的随机数 但是不包含1 的浮点数
list=[1,2,3,4,5,6]
random.shuffle(list) #将list里面的数据 随机排序
print(list)
#随机生产一个实数 他在[3,9]范围
bb=random.uniform(3,9)
print(bb)
实列 : 数学函数简单彩票系统 import random #导入随机数模块 import math #到人数学模块 num=int(input("请输入你的号码:")) res=random.choice(range(100))+1 if num==res: print("你中奖了") else: print("你没中奖了")
十. 运算符
# 表答式: 有变量 常量和运算符组成的式子
# 阅读:表答式
# 功能：
# 值:
# 算术运算符和算术运算表达式
# 算术运算符
# + - * / % ** //
# 加 减 乘 除 取模 幂 取整
# 算术表达式:
num1=5
num2=3
print(num1+num2) # 8
print(num1-num2) # 2
print(num1*num2) # 15
print(num1/num2) #1.6666666667
print(num1%num2) # 2
print(num1**num2) #125
print(num1//num2) #1
赋值运算符 =
变量=表达式
aa=5
符合运算符
+= a+=b a=a+b
*= a*=b a=a*b
/= a/=b a=A/b
%= a%=b a=a%b
**= a**=b a=a**b
//= a//=b a=a//b
十一. if . for . while . break . 语句:
# 格式:
# if表达式:
# 语句
num=6
num2=7
if num==num2:
print("yes")
else:
print("no")
# -*- coding: UTF-8 -*-
# f 语句的判断条件可以用>（大于）、<(小于)、==（等于）、>=（大于等于）、<=（小于等于）来表示其关系。
# 当判断条件为多个值时，可以使用以下形式：
# if 判断条件1:
# 执行语句1……
# elif 判断条件2:
# 执行语句2……
# elif 判断条件3:
# 执行语句3……
# else:
# 执行语句4……
num = 5 if num == 3: # 判断num的值 print 'boss' elif num == 2: print 'user' elif num == 1: print 'worker' elif num < 0: # 值小于零时输出 print 'error' else: print 'roadman' # 条件均不成立时输出
# 死循环 表达式永远为真的循环
while 2: print("哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈") var = 1 while var == 1 : # 该条件永远为true，循环将无限执行下去 num = raw_input("Enter a number :") print "You entered: ", num
# while 表达式:
# 语句
# else:
# 语句1
# 逻辑:在条件语句（表达式）为else时执行else的"语句2"
a=1 while a<=3: print("真的") a+=1 else: print("假的")
#练习if语句
aa=int(input("请你输入一个数是否是奇偶:"))
if aa%2==0:
print("是偶数")
else:
print("是奇数")
# aa=153%10 #3 各位 # aa=153//10 #15 # aa=153//10%10 # 5 十位 #aa=153//100 #1 百位 # #求水仙花树 num =int(input("请输入一个数:")) aa=num%10 bb=num//10%10 cc=num//100 if num==aa**3+bb**3+cc**3: print("是水仙花数") else: print("不是一个水仙花数")
#找最大值 num1=int(input()) num2=int(input()) num3=int(input()) max=num1 #假设 if num2>num1: max=num2 if num3>max: max=num3 print("max=",max)
# # 输出一到五的值: num=0 while num<5: num=num+1 print(num) # 1 # 2 # 3 # 4 # 5 # # 计算100一百的和 sum=0 num=1 while num<=100: sum+=num num+=1 print(sum) #5050 # # 打印字符串没一个 str="ABCDEFGAAAAAAAAAAA" index=0 while index<len(str): print( index,str[index]) index+=1 # 1 ==== B # 2 ==== C # 3 ==== D # 4 ==== E # 5 ==== F # 6 ==== G # 输出所有三位数的水仙花数 num=100 while num<=999: a=num%10 b=num//10%10 c=num//100 if num==a**3+b**3+c**3: print(num) num+=1 # 153 # 370 # 371 # 407 # 判断输入一个数是不是质数 # num=int(input("输入一个数是不是质数:")) # if num==2: # prin("是质数") # index=2 # while # 计算字符串的下标的和 # str=input("请输入字符串:") index=0 sum=0 while index<len(str): if str[index]>="0" and str[index]<="9": sum+=int(str[index]) index+=1 print(sum) 字符串比较大小是比的ASCII的值
# for 语句
# 格式:
# for 变量名 in 集合
# 语句
for aa in 'Python': # 第一个实例 print ('当前字母 :', aa) # 当前字母 : P # 当前字母 : y # 当前字母 : t # 当前字母 : h # 当前字母 : o # 当前字母 : n
fruits = ['banana', 'apple', 'mango'] for bb in fruits: # 第二个实例 print ('当前字母 :', bb) # 当前字母 : banana # 当前字母 : apple # 当前字母 : mango
# range() 函数 列表生成器
# 功能:生成数列
print(range(10)) #range(0, 10) for aa in range(5): print(aa) #0 1 2 3 4
for b in range(2,20,2): print(b) # # 2 # 4 # 6 # 8 # 10 # 12 # 14 # 16 # 18
# break语句用来终止循环语句，即循环条件没有False条件或者序列还没被完全递归完，
# 也会停止执行循环语句。
# break语句用在while和for循环中。
# 注意只能结束最近的循环 就是当前循环
# 注意循环中可以有else语句 break导致循环截止 不会执行else里的语句
#!/usr/bin/python # -*- coding: UTF-8 -*- for letter in 'Python': # 第一个实例 if letter == 'h': break print ('当前字母 :', letter) # 当前字母 : P # 当前字母 : y # 当前字母 : t
var = 10 # 第二个实例 while var > 0: print ('当前变量值 :', var) var = var -1 if var == 5: # 当变量 var 等于 5 时退出循环 break # 当前变量值 : 10 # 当前变量值 : 9 # 当前变量值 : 8 # 当前变量值 : 7 # 当前变量值 : 6
# 注意循环中可以有else语句 break导致循环截止 不会执行else里的语句
num=1
while num<=10:
print(num) # 1 2 3
if num==3:
break
num+=1
else:
print("因为有braek就不会执行else中的语句") # Python continue 语句跳出本次循环，而break跳出整个循环。
# continue 语句用来告诉Python跳过当前循环的剩余语句，然后继续进行下一轮循环。
# continue语句用在while和for循环中。
# 当前最近的循环
for letter in 'Python': # 第一个实例 if letter == 'h': continue print ('当前字母 :', letter) # 当前字母 : P # 当前字母 : y # 当前字母 : t # 当前字母 : o # 当前字母 : n #
var = 10 # 第二个实例 while var > 0: var = var -1 if var == 5: continue print ('当前变量值 :', var) # 当前变量值 : 9 # 当前变量值 : 8 # 当前变量值 : 7 # 当前变量值 : 6 # 当前变量值 : 4 # 当前变量值 : 3 # 当前变量值 : 2 # 当前变量值 : 1 # 当前变量值 : 0 #
十二. 运算符和表达式
# 位运行算
# & 按位与运算符
# 相应得位数都为1 则该为的结果是1否则为0
print(5&7)
101
111
-----
101
| 按位或运算符
两个二进制位有个位1时 结果为1
print(5|7)
101
111
------
111
^按位抑或运算符
二进制两位相异或
print(5^7)
101
111
----
010
~按位取反运算符
每个二进制数据位取反
prin(~5)
<< 左移运算符
各二进制全部左移若干位 <<右侧的数字决定高位舍去低位补零
print(2<<2)
>>右位移运算符
各二进制全部右移若干位 由>>右侧数字决定
prin(13>>2)
十三. 关系运算符
== != > < >= <=
关系表达式
1+2>3+4
格式 : 表达式 关系运算符 表达式2
逻辑运算符
逻辑与 and
逻辑与运算符表达式 表达式1 and 表达式2
有一个为假就为假 其他为真
逻辑或 or
逻辑或运算符表达式 表达式1 or 表达式2
假假为假 其他为真 (有一个为真都为真)
逻辑非 not 逻辑非运算符表达式 or 表达式1
就假的说的真的 真的说成假的
短路原则
表达式1 and 表达式2 and 表达式3 and 表达式4.....and 表达式n
成员运算符
in 如果在指定的序列中找到了值返回true 否则返回fales
not in 意思在指定的序列中没有找到值返回true 否则返回fales
身份运算符
is : 判断两个标识符是不是引用同一个对象
is not ：判断两个标识符是不是引用不同的对象
运算符优先级
**
~ + - (一元加减)
*/ % //
+ -
>> <<
&
<= < > >=
== !=
= %= += //=
is is not
in not in
#能被4整除 但是不能被100整除 或者 能被400整除 year=int(input("请你输入一个数字:")) if year%400==0 or(year%4==0 and year%100!=0): print("是闰年") else: print("不是闰年")
四十. 字符串
# # 什么是字符串
# # 就是以 单引号或者双引号引起来的任意文本
# # 'ancask的库时时刻刻'
# # "ABC事实就是惊声尖叫"
# # 创建字符串:
# str1="abcde骨灰盒fgaa"
# str2="abcde吾问无为谓fgaa"
# str3="abcdefg少时诵诗书所所aa"
# # 字符串运算
# 字符串连接
# str6="SKSDK就是死你KsbDSKDKSKK"
# str9="ASSASADADA1111"
# str=str6+str9
# print(str)
# 输出重复字符串
# str7="J数据的技术角度讲"
# str10=str7*3
# print(str10)
# 访问字符串中某一个字符 索引重零开始
# 字符串名[下标]
# 注意字符串不可变
# str="4555555555*5555SSSJSJSJ"
# print(str[1])
#截取字符串
# str5="ABCDEC"
# str6=str5[1:4] #从1截取到4但是不包含4
# print(str6) #BCD
# str5="ABCDEC"
# str6=str5[:4] 截取下标之前
# print(str6)#ABCD
# str5="ABCDEC"
# str6=str5[2:] #截取到末尾
# print(str6)#CDEC
#判断:
# str="HELLOW name"
# print("name" in str ) #True
# print("str5" not in str) #True
#将字符串str 当成有效的表达式来求返回计算结果
#eval(str) 功能 将字符串str 当成有效的表达式来求返回计算结果
num1=eval("123")
print(num1) #123
print( type(num1)) #<class 'int'>
print( eval("12+6")) #18
print( eval("12-6")) #6
print( eval("-126")) #-126
# len(srt) 返回字符串长度 就是字符个数
print( len("AAA"))
#lower() 将字符串里面的大写字母转换成小写
str6="abcFEG"
print(str6.lower()) #abcfeg
#upper() 将字符串里面的小写字母转换成大写
str9="abclktttttttttttggggggFEG"
print(str9.upper()) #ABCLKTTTTTTTTTTTGGGGGGFEG
print("AAAAAAAAAA".upper()) #AAAAAAAAAA
#swapcase() 将字符串里面大写字母转小写 小写转大写
str7="AI LOVER you header"
print(str7.swapcase()) #ai lover YOU HEADER
#capitalize() 首字母大写 其他小写
str0="i have you to"
print(str0.capitalize()) #I have you to
# title() 每个单词的首字母大写
str2="have to nice"
print(str2.title()) #Have To Nice
# string.center(width)
# 返回一个原字符串居中,并使用空格填充至长度 width 的新字符串
#center(width,fillchar)
str77="wo ai nice lover"
print(str77.center(40,"*")) #************wo ai nice lover************
# string.ljust(width)
# 返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串
stra="wo ai nice lover"
print(stra.ljust(40,"%")) #wo ai nice lover%%%%%%%%%%%%%%%%%%%%%%%%
# string.zfill(width)
# 返回长度为 width 的字符串，原字符串 string 右对齐，前面填充0
strb="wo ai nice lover"
print(strb.zfill(40)) #000000000000000000000000wo ai nice lover
# 返回字符串中str出现的次数 可以指定一个范围 默认从头到尾
# count(str[,start][,end])
str11="wo ai nice lover and lover to hao lover"
print(str11.count("lover")) #3
print(str11.count("lover",7,len(str11))) #3
#从左到右的 第一次出现的下标数 没有就返回-1
# string.find(str, beg=0, end=len(string))
# 检测 str 是否包含在 string 中，如果 beg 和 end 指定范围，
# 则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1
str10="wo ai nice lover and lover to hao lover"
print(str10.find("lover")) #11
print(str10.find("ov")) #12
print(str10.find("lover",15,len(str10))) #21
# string.index(str, beg=0, end=len(string))
# 跟find()方法一样，只不过如果str不在 string中会报一个异常.
str18="aaaAAcBBBB"
print(str18.index("A"))#3
# string.lstrip()
# 截掉 string 左边的空格
# 默认是空格
str19=" wo ai nice lover and lover to hao lover"
print(str19.lstrip()) #wo ai nice lover and lover to hao lover
# string.rstrip()
# 截掉 string 右边的空格
# 默认是空格
str22=" wo ai nice lover and lover to hao lover "
print(str22.strip()) #wo ai nice lover and lover to hao lover
# string.strip([obj]) 去掉左右空格
# 在 string 上执行 lstrip()和 rstrip()
str28=" pppp ai nice lover and lover to hao lover "
print(str28.strip()) #pppp ai nice lover and lover to hao lover
# Python replace()
# old（旧字符串） 替换成 new(新字符串)，如果指定第三个参数max，则替换不超过 max
str3="this is string example....wow!!! this is really string";
print (str3.replace("is", "was")); #thwas was string example....wow!!! thwas was really string
print (str3.replace("is", "was", 3));#thwas was string example....wow!!! thwas is really string
# Python isnumeric() 方法检测字符串是否只由数字组成。这种方法是只针对unicode对象。
# 注：定义一个字符串为Unicode，只需要在字符串前添加 'u' 前缀即可，具体可以查看本章节例子。
# 如果字符串中只包含数字字符，则返回 True，否则返回 False
str55 = u"this2009";
print(str55.isnumeric()); #False
str11= u"23443434";
print (str11.isnumeric()); #True
# Python join() 方法用于将序列中的元素以指定的字符连接生成一个新的字符串
str = "-"
seq =("a", "b", "c")
print(str.join( seq )) #a-b-c
# 以什么分截取字符串 变成list列表
# split(str)
str55="AS-LOLSOLLS-ollll-kkk-LLLLL"
print(str55.split("-")) #['AS', 'LOLSOLLS', 'ollll', 'kkk', 'LLLLL']
str56="AS-LOLSOLLS-ollll-kkk-LLLLL-HHHHHHHHHH-000000000"
print(str56.split("-",3)) # ['AS', 'LOLSOLLS', 'ollll', 'kkk-LLLLL-HHHHHHHHHH-000000000']
# 看这个字符串里面有多少个单词
str57="AS-LOLSOLLS-ollll-kkk-LLLLL-HHHHHHHHHH-000000000"
aa=str57.split("-")
c=0
for x in aa:
if len(x)>0:
c+=1
print (c) # 7
# Python max() 方法返回字符串中最大的字母。
# Python min() 方法返回字符串中最小的字母。
str = "this-is-real-string-example....wow!!!";
print ("Min character: " + min(str))
# Min character: !
# 了解
# # Python maketrans() 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，
# # 第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
# a = "aeiou"
# b = "12345"
# trantab = maketrans(a, b)
# str = "this is string example....wow!!!"
# print (str.translate(trantab))
# 在给定的范围内判断是否以给定的字符串开头 如果没有指定范围默认的整个字符串
str50="I have is dream"
print(str50.startswith("I")) # //True
# 在给定的范围内判断是否以给定的字符串结尾 如果没有指定范围默认的整个字符串
str51="I have is dream"
print(str51.endswith("dream")) #True
# isalpha()是判断字符串中至少有一个字符且所有的字符都是字母返回true 否则返回fales
str56="Ihaveisdream"
print(str56.isalpha()) # True
# isipper() 英文
# 如果字符串中至少有一个字符且所有的字符都是大写的英文字母返回 true 与false
print("SBC".isupper()) #True
print("SBb".isupper()) #False
print("SB123".isupper()) #True
print("Sa123".isupper()) #False
istitle() 方法检测字符串中所有的单词拼写首字母是否为大写，且其他字母为小写。
str = "This Is String Example...Wow!!!"
print (str.istitle()) #True
Python isspace() 方法检测字符串是否只由空白字符组成。
如果字符串中只包含空格，则返回 True，否则返回 False.
str = " "
print (str.isspace()) #True
实例
str="""9月6日，WePhone的创始人兼开发者苏享茂在Google+留
1下一份网帖称，前妻翟某某向他索要1000万人民币和一套房产。
2由于自己没有1000万又走投无路，将要因此离开人世，并在相册中留下
3与前妻的对话截图。9月9日，“北京时间”记者从苏享茂家属处获悉，苏享茂于9
4月7日凌晨五点左右在公司附近的住所处跳楼自杀。苏享茂公布的遗书内容，尚没有得到翟某某回应。
59月6日，WePhone创始人兼开发者苏享茂用GoogleIDW
6nQiangXu发帖，称自己被恶毒前妻相逼，将要离开人世，WePhone
7以后将停止运营等信息，并附上前妻手机号码、工作单位。此外，苏享茂还在相册中上传自己与前妻的聊
8天截图，以及两人签署的离婚合约。网帖称，自己的前妻翟
9某某通过以下两点要挟自己：
0"""
aa=str.splitlines(True)
print(aa)
十五. 格式化输出
实例:
print("MY name is hellow jiab")
num=10
str="哈哈哈哈哈哈哈哈"
str2="17760453112"
#占位符 %d %f %s
#转义字符 \
print("num=%d，str=%s"%(num,str) )
十六. 布尔值和空值
# //布尔值就只有两种: True 和 false
b1=True
b2=false
print(b1,b2)
空值:是python中一个特殊的值 用None 来表示
None 不能理解
因为；零是有意义的
而None是一个特殊值
n=Noen
print(n Noen
十七. 列表(list)
# 列表 是一种有序的集合 来存储大量的数据
age1=32
# age2=22
# age3=45
# age4=42
# age5=49
# age6=450
# print((age1+age2+age3+age4+age5+age6)/5) #128
# 创建列表
# 格式: 列表名=[列表选项1,列表选项2,列表选项3,列表选项4,列表选项5]
# 创建一个空列表
# list1=[]
# 创建一个有元素的列表
# list2=[12,13,15,44]
# 注意: 列表中的元素数据 可以是不同类型的数据
# list3=[1,2,3,"SHSHSHH","nice",True]
# print(list3)
# 列表元素的访问
# 取值: 格式 列表名[下标]
# 注意:访问不要越界
# list4=[1,2,3,5,6]
# print(list4[2]) #3
# 替换:
# list4=[2]=300
# print(list4) #1 2 300 6
# # 求列表中的平均值 list5=[22,23,24,25,66] index=0 sum=0 while index<5: sum+=list5[index] index+=1 if index==5: print(sum/5)
# 列表组合
# list6=[0,23,25,5]
# list7=[1,6]
# list8=list6+list7
# print(list8) #[0,23,25,5,1,6]
# 列表重复
# list9=[1,2,3]
# list10= list9*3
# print(list10) #[1,2,3,1,2,3,1,2,3]
# 判断元素是否在列表中
# list11=[1,2,3]
# print(3 in list11) #判断3在不在列表中 在返回 True
# # 列表截取
# list12=[4,5,6,7,8,9]
# print(list12[2:5]) # 6,7,8 截取2到5这个范围中
# print(list12[2:]) # 6 7 8 9 截取到最后
# print(list12[:5]) # 4 5 6 7 8 截取到下标5之前的下标
# # 二维列表
# list55=[[1,9,8],[2,3,4,6] ,[2,88,6,5]]
# #8
# print(list55[1][1]) #3
# print(list55[0][1]) #9
# print(list55[2][1]) #88
# # 列表方法
# # 该方法无返回值，但是会修改原来的列表
# # 在列表末尾添加新的对象 list.append(obj)追加一个元素到末尾
# aList = [123, 'xyz', 'zara', 'abc']
# List.append( 2009 )
# print ("Updated List : ", aList) #Updated List : [123, 'xyz', 'zara', 'abc', 2009]
# list5=[5,6,9]
# list5.append(6)
# list5.append([5,6])
# print(list5) #[5,6,9,6,[5,6]]
# 追加多个元素 在末尾一次性追加一个列表中多个值
# 该方法没有返回值，但会在已存在的列表中添加新的列表内容
# 以下实例展示了 extend()函数的使用方法：
# aList = [123, 'xyz', 'zara', 'abc', 123];
# bList = [2009, 'manni'];
# aList.extend(bList)
# print ("Extended List : ", aList ) #[123, 'xyz', 'zara', 'abc', 123, 2009, 'manni']
# insert() 函数用于将指定对象插入列表的指定位置。
# index -- 对象 obj 需要插入的索引位置。
# obj -- 要插入列表中的对象。
# aList = [123, 'xyz', 'zara', 'abc']
# aList.insert( 3, 2009)
# print ("Final List : ", aList) #[123, 'xyz', 'zara', 2009, 'abc']
# pop() 函数用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值。
# obj -- 可选参数，要移除列表元素的索引值，不能超过列表总长度，默认为 index=-1，删除最后一个列表值。
# 该方法返回从列表中移除的元素对象。
# list1 = ['Google', 'Runoob', 'Taobao']
# list_pop=list1.pop(1)
# print ("删除的项为 :", list_pop)
# print ("列表现在为 : ", list1)
# 删除的项为 : Runoob
# 列表现在为 : ['Google', 'Taobao']
# remove() 函数用于移除列表中某个值的第一个匹配项
# obj -- 列表中要移除的对象。
# 该方法没有返回值但是会移除列表中的某个值的第一个匹配项。
# aList = [123, 'xyz', 'zara', 'abc', 'xyz'];
# aList.remove('xyz');
# print ("List : ", aList) # [123, 'zara', 'abc', 'xyz']
# aList.remove('abc');
# print ("List : ", aList;) #[123, 'zara', 'xyz']
# 清楚列表中所有的数据
# list99=[56,78,94,2]
# list99.clear()
# print(list99) #[]
# 从列表中找出某个值得下标 第一个匹配的索引值
# list4=[2,3,4,6,3]
# list5=list4.index(3)
# print(list5) #1
# aList = [123, 'xyz', 'zara', 'abc'];
# print "Index for xyz : ", aList.index( 'xyz' ) ; # 1
# print "Index for zara : ", aList.index( 'zara' ) #2
# 列表中元素的个数
# list66=[2,5,46,78,8]
# print(len(list66)) #5
# reverse() 函数用于反向列表中元素。
# reverse()方法语法：
# 该方法没有返回值，但是会对列表的元素进行反向排序。
# aList = [123, 'xyz', 'zara', 'abc', 'xyz']
# aList.reverse()
# print ("List : ", aList) # ['xyz', 'abc', 'zara', 'xyz', 123]
# 获取列表中最小的值
# list22=[78,9,4,5]
# print(min(list22)) #4
# 返回元素在列表中出现的次数
# count() 方法用于统计某个元素在列表中出现的次数。、
# 查看一个元素在列表中出现了多少次
# cont()
# list8=[1,2,3,45,2,9,66,2,8,2]
# print(list8.count(2)) #4
# 删除列表中多次出现的元素 # list66=[5,56,89,6,5,36,5,6,5] # all=list66.count(5) #4 # Index=0 # while Index<all： # list66.remove(5) # index+=1 # print (list66)
# sort() 函数用于对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数。
# sort()方法语法：
# list.sort(cmp=None, key=None, reverse=False)
# cmp -- 可选参数, 如果指定了该参数会使用该参数的方法进行排序。
# key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
# 将元组转换成列表
a=list((1,2,3,4))
print (a) # [1, 2, 3, 4]
# 拷贝(浅拷贝)
list2=[12,3,45,66]
list3=list2
list3[1]=200
print(list3) # [12, 200, 45, 66]
print(list2) #[12, 200, 45, 66]
print(id(list3)) # 6355144
print(id(list2)) # 6355144
# 深拷贝 内存拷贝
list30=[1,2,3,4,5]
list31=list30.copy()
list30[1]=200
print(list30) # [1, 200, 3, 4, 5]
print(list31) # [1, 2, 3, 4, 5]
print(id(list30)) # 39035784
print(id(list31)) # 39383944
# 输出10个数字找出第二大值 # listNum=[] # num=0 # while num <5: # val=int(input("请输入5个数:")) # listNum.append(val) # num+=1 # print (listNum) # # 升序排列 # listNum.sort() # print (listNum) # count=listNum.count(listNum[len(listNum)-1]) # c=0 # while c<count: # listNum.pop() # c+=1 # print(listNum[len(listNum)-1]) # 请输入5个数:65 # 请输入5个数:55 # 请输入5个数:32 # 请输入5个数:88 # 请输入5个数:57 # [65, 55, 32, 88, 57] # [32, 55, 57, 65, 88] # 65 #90=2*3*3*5 num=int(input("输入一个是因式分解")) i=2 while num!=1: if num%i==0: num//=i print("i=",i) print("num=",num) else: i+=1
十八. 绘图模块
# 导入绘图模块
# import turtle
# turtle.forward
十九. 元组
# Python的元组与列表类似，不同之处在于元组的元素不能修改。
# 元组使用小括号，列表使用方括号。
# 元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。
# 创建空元组
# tup1 = ();
# 元组中只包含一个元素时，需要在元素后面添加逗号
# tup1 = (50,);
# 元组可以使用下标索引来访问元组中的值
# 格式:元组名:下标
tup1 = ('physics', 'chemistry', 1997, 2000);
tup2 = (1, 2, 3, 4, 5, 6, 7 );
print (tup1[0]) #physics
print (tup2[1:5]) #(2, 3, 4, 5)
print (tup2[-1]) #7 元组获取最后一个元素-1 倒数是从-1开始
# 元组不能变 是指元组里面的元素不可以改变
# 元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，如下实例:
tup1 = (12, 34.56);
tup2 = ('abc', 'xyz');
# 创建一个新的元组
tup3 = tup1 + tup2;
print (tup3); #(12, 34.56, 'abc', 'xyz')
# tup6=(1,2,3,[7,8,9])
# tup6[-1][1]=1000
# print(tup6) # (1, 2, 3, [7, 1000, 9])
# 元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组
# tup6=(1,2,3,[7,8,9])
# del tup6
# 元组连接
t1=(1,2,3)
t2=(10,25,39)
t3=t1+t2
print(t3) # (1, 2, 3, 10, 25, 39)
# 元组重复
# t1=(1,2,3)
# print(t1*3) #(1, 2, 3, 1, 2, 3, 1, 2, 3)
# # 判断元素是否在元组里
# t5=(1,2,3,20)
# print(20 in t5) #True
# 元组截取
# 格式 :
# 元组名:[开始下标:结束下标]
# 从开始下标 到结束下标之前
# t9 = ('physics', 'chemistry', 1997, 2000);
# tup8 = (1, 2, 3, 4, 5, 6, 7 );
# print (tup9[0]) #physics
# print (tup8[1:5]) #(2, 3, 4, 5)
# 二维元组 :就是元素为一维元组的的元组
t0=((1,2,3),(4,5,6),(7,8,9))
print(t0[1][1]) #5
# 元组的方法
# Python 元组 len() 函数计算元组元素个数。
# tuple2 = (123, 'xyz', 'zara')
# aa=len(tuple2)
# print(aa) #3
# Python 元组 max() 函数返回元组中元素最大值。
ta=(123, 'xyz', 'zara', 'abc')
print(max(ta)) #zara
# Python 元组 tuple() 函数将列表转换为元组。
aList = [123, 'xyz', 'zara', 'abc'];
aTuple = tuple(aList)
print (aTuple) #(123, 'xyz', 'zara', 'abc')
# 元组的遍历
for x in (1,2,3,4,5,6):
print(x) #123456
二十. 字典
# 字典是另一种可变容器模型，且可存储任意类型对象。
# 字典的每个键值(key=>value)对用冒号(:)
# 分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中 ,格式如下所示
# 键必须是唯一的，但值则不必。
# 值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。
# 字典存储数据是无序的存储
# 一个简单的字典实例：
dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}
# 也可如此创建字典：
dict1 = { 'abc': 456 };
dict2 = { 'abc': 123, 98.6: 37 };
# 元素的访问
dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
print(dict["Name"]) #Runoob 没有就会报错
print(dict.get("Name")) #Runoob 如果字典有就获取到这个元素 没有也不会报错
# 添加
dict1= {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
dict1["age"]=22
print(dict1) #{'age': 22, 'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
# 修改
dict2= {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
dict2["Class"]=10000
print(dict2) # {'Class': 10000, 'Name': 'Runoob', 'Age': 7}
# 删除字典元素
# 能删单一的元素也能清空字典，清空只需一项操作。
# 显示删除一个字典用del命令，如下实例：
dict3 = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
del dict['Name'] # 删除键 'Name'
dict.clear() # 清空字典
del dict # 删除字典
# 字典遍历 dict6= {'Name': 'Runoob', 'Age': 7, 'Class': 'First'} for key in dict6: print(key) # Class # Age # Name
dict4= {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
for key in dict4:
print(key,dict4[key])
# Age 7
# Class First
# Name Runoob
dict7= {'Name': 'Runoob', 'Age': 22, 'Class': 'First'}
for value in dict7.values():
print(value)
# 22
# Runoob
# First
dict8= {'Name': 'Runooeeeeeb', 'Age': 22, 'Class': '哈哈哈哈哈'}
for k,v in dict8.items():
print(k,v)
# Name Runooeeeeeb
# Age 22
# Class 哈哈哈哈哈
# enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，
# 同时列出数据和数据下标，一般用在 for 循环当中。
# enumerate(sequence, [start=0])
# 参数
# sequence -- 一个序列、迭代器或其他支持迭代对象。
# start -- 下标起始位置。
dict10= {'Name': 'RAAAAAA', 'Age': 220000, 'Class': '哈哈哈哈AAAA哈'}
for k,v in enumerate(dict10):
print(k,v)
# 0 Age
# 1 Class
# 2 Name
字典和list列表比较
字典 :查找和插入的速度极快 不会随着key value 增加而加慢
需要占用大量的内存
list
查找和插入的速度随着数据的增多而 速度会减慢
占用空间小 浪费的内存少
# 字典是另一种可变容器模型，且可存储任意类型对象。
# 字典的每个键值(key=>value)对用冒号(:)
# 分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中 ,格式如下所示
# 键必须是唯一的，但值则不必。
# 值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。
# 字典存储数据是无序的存储
# 一个简单的字典实例：
dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}
# 也可如此创建字典： dict1 = { 'abc': 456 }; dict2 = { 'abc': 123, 98.6: 37 };
# 元素的访问
dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
print(dict["Name"]) #Runoob 没有就会报错
print(dict.get("Name")) #Runoob 如果字典有就获取到这个元素 没有也不会报错
# 添加
dict1= {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
dict1["age"]=22
print(dict1) #{'age': 22, 'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
# 修改
dict2= {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
dict2["Class"]=10000
print(dict2) # {'Class': 10000, 'Name': 'Runoob', 'Age': 7}
# 删除字典元素
# 能删单一的元素也能清空字典，清空只需一项操作。
# 显示删除一个字典用del命令，如下实例：
dict3 = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
del dict['Name'] # 删除键 'Name'
dict.clear() # 清空字典
del dict # 删除字典
# 字典遍历
dict6= {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
for key in dict6:
print(key)
# Class
# Age
# Name
dict4= {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
for key in dict4:
print(key,dict4[key])
# Age 7
# Class First
# Name Runoob
dict7= {'Name': 'Runoob', 'Age': 22, 'Class': 'First'}
for value in dict7.values():
print(value)
# 22
# Runoob
# First
dict8= {'Name': 'Runooeeeeeb', 'Age': 22, 'Class': '哈哈哈哈哈'}
for k,v in dict8.items():
print(k,v)
# Name Runooeeeeeb
# Age 22
# Class 哈哈哈哈哈
# enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，
# 同时列出数据和数据下标，一般用在 for 循环当中。
# enumerate(sequence, [start=0])
# 参数
# sequence -- 一个序列、迭代器或其他支持迭代对象。
# start -- 下标起始位置。
dict10= {'Name': 'RAAAAAA', 'Age': 220000, 'Class': '哈哈哈哈AAAA哈'}
for k,v in enumerate(dict10):
print(k,v)
# 0 Age
# 1 Class
# 2 Name
字典和list列表比较
字典 :查找和插入的速度极快 不会随着key value 增加而加慢
需要占用大量的内存
list
查找和插入的速度随着数据的增多而 速度会减慢
占用空间小 浪费的内存少
案例1 : 作业讲解歌词下一秒
dict={} #空字典
# Python splitlines() 按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，
# 如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。
aa=str.splitlines()
# print(aa) # 1
for bb in aa: #循环每一行
# print(bb) #2
cc=bb.split("]")
# print(cc)
# print(cc[0])
# print(len(cc))
for i in range(len(cc)-1):
# print(i)
dd=cc[i][1:]
# print(dd)
timelist=dd.split(":")
time=float(timelist[0])*60+float(timelist[1])
dict[time]=cc[-1]
print(dict)
案例2 : 作业时间一秒 :
# 时间下一秒 # 千锋教育 [函数基础01] # 12：23:23 timeStr=input("请输入时分秒:") timelist=timeStr.split(":") h=int(timelist[0]) m=int(timelist[1]) s=int(timelist[2]) s+=1 if s==60: m+=1 s=0 if m==60: h+=1 m=0 if h==24: h=0 print(h,m,s)
str="[02:05.32][03:05.45][04:54.56]" str2=str.split("]") # ['[02:05.32', '[03:05.45', '[04:54.56', ''] # # # # [02:05.32 # [03:05.45 # [04:54.56 for index in str2: print(index[1:]) # 02:05.32 # 03:05.45 # 04:54.56 aa={} bb="KSKKSK" cc="卡卡卡卡" aa[bb]=cc print(aa) # {'KSKKSK': '卡卡卡卡'}
二十一. set集合
# set() 类似字典(dict) 是一组key 集合 不存储
# 本质: 无序 和 无重复的元素的集合
# 创建:
# 创建set 需要 一个列表(list)或者元组(tuple)或者字典(dict)作为输入的集合
# 重复元素可以在set中自动过滤
s1=set([1,2,3,4,5,6,7])
print(s1) #{1, 2, 3, 4, 5, 6, 7}
# 重复元素可以在set中自动过滤
s2=set([1,2,3,4,1,2,3])
print(s2) #{1, 2, 3, 4}
s3=set((10,22,33,4,10,22,33))
print(s3) #{33, 10, 4, 22}
# set() 类似字典(dict) 是一组key 集合 不存储
s4=set({"name":"小明","age":25,"study":"python"})
print(s4) #{'study', 'age', 'name'}
# set添加 add
s5=set([1,2,3])
s5.add(1000)
print(s5) #{1000, 1, 2, 3}
s5.add(3) #可以添加重复的元素 但是不会有效果
# s5.add([7,8,9]) # set 的元素不能是列表 因为列表是可变的
s5.add((7,9,6))
print(s5) # {1000, 1, 2, 3, (7, 9, 6)} 因为元组不可变所有能添加进去
# s5.add({"name":"张三"})
# print(s5) #set的元素不能是字典 因为字典是可变的
# 添加更新update
# update 插入添加整个 list tuple 字符串打乱了
s6=set([1,2,3])
s6.update([6,7,9])
print(s6) #{1, 2, 3, 6, 7, 9} 字符串打碎查入了
s7=set([1,2,3])
s7.update((45,46,47))
print(s7) #1, 2, 3, 45, 46, 47}
s8=set([1,2,3])
s8.update(("name"))
print(s8) #{1, 2, 3, 'a', 'e', 'n', 'm'}
# 删除
s9=set([1,2,3])
s9.remove(2)
print(s9) #{1, 3}
# set是没有索引的
# 循环遍历
s10=set([1,2,3,4,5,6]) for i in s10: print(i) #1 2 3 4 5 6
s11=set("name") for i in s11: print(i) #n a m e
# set里面有交集和并集
# 交集 &
str12=set([1,2,3,4,5]) str13=set([11,2,3,44,55]) a1=str12&str13 print(a1) #{2, 3} print(type(a1)) #<class 'set'>
# 并集 |
str12=set([1,2,3,4,5]) str13=set([10,2,3,6]) a2=str12|str13 print(a2) #{1, 2, 3, 4, 5, 6, 10} print(type(a2)) #<class 'set'>
数据转换
# list ----set a1=[1,2,3,4,5,6] a2=set(a1) print(a2) #{1, 2, 3, 4, 5, 6} # tuple----set a3=(1,2,3000,4,5,600000) a4=set(a3) print(a4) #{600000, 1, 2, 4, 5, 3000} # set----list a5={1000,200,3000,400,500,} a6=list(a5) print(a6) #[400, 3000, 200, 1000, 500] #set-----tuple a7={9999,11,1000,400,20000,} a8=tuple(a7) print(a8) #(20000, 400, 1000, 11, 9999)
二十二. os 模块
# 导入模块
import os
# 获取操作系统类型 nt--->windows
#max os x #苹果操做系统
# print(os.name) # nt 代表是window模块
# # 打印操作系统详细信息(目前只有在liux系统和mac系统上打印)
#print(os.uanme) # windows不支持
# 获取操作系统中的环境变量
print(os.environ)
# 获取指定环境变量
print(os.environ.get("PROGRAMFILES"))
# 获取当前目录 ./
print(os.curdir) # .
# 获取当前工作目录 即当前python 脚本所在的目录
print(os.getcwd()) #E:\Studypython\py2
# 返回指定目录下的所有文件 以列表的形势 包含文件目录
print(os.listdir(r"E:\Studypython\py2\1"))#['01.txt', '02.txt', '03.txt', '04.txt', '05.txt']
# 创建文件目录
# os.mkdir("Study")
# 删除目录
# os.rmdir("Study")
# 创建绝对目录
# os.mkdir(r"E:\Studypython\py2\2\HHH")
# 获取文件属性
# print(os.stat("Study"))
# os.stat_result(st_mode=16895, st_ino=16888498602707557, st_dev=806918758,
# st_nlink=1, st_uid=0, st_gid=0, st_size=0, st_atime=1527945156,
# st_mtime=1527945156, st_ctime=1527945156)
# 重命名
# os.rename("Study","HHH")
# 删除普通文件
# os.remove("HHH\1.txt")
# 运行shell命令
# os.system("notepad")
# os.system("write")
# 有些方法存在os模块里 还有些存在于os.path
# 查看当前的绝对路径
# prin(os.path.abspath("./HHH"))
# 拼接路径
# 注意参数二开始不能有斜杠
p1=r"E:\Studypython\py2\HHH"
p2="name11"
print(os.path.join(p1,p2)) #E:\Studypython\py2\HHH\name11
# 拆分路径
path2=r"E:\Studypython\py2\HHH"
print(os.path.split(path2)) #('E:\\Studypython\\py2', 'HHH')拆分就变成元组了
# 获取扩展名
path3="D:\tx\QQLive\Log\QXMatrix_dll_14-35-26_7300.log"
print(os.path.splitext(path3))
# ('D:\tx\\QQLive\\Log\\QXMatrix_dll_14-35-26_7300', '.log')
# 判断是否为目录
print(os.path.isdir(path3)) #False
# 判断文件是否存在
print(os.path.isfile("HHH")) #False
# 判断目录是否存在
path6= r"F:\dbnodeloginmd5"
print(os.path.exists(path6)) # True
# 获取文件大小
path9= r"F:\dbnodeloginmd5\login.js"
print(os.path.getsize(path9)) #1717字符
# 获取文件目录
path10= r"F:\dbnodeloginmd5\login.js"
print(os.path.dirname(path10)) # F:\dbnodeloginmd5
# 获取文件名
print(os.path.basename(path10)) #login.js
返回指定路径下的文件和文件夹列表
os.listdir(path)
1362
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
