python基础-入门

主要包括：

1.变量

2.用户输入

3.if...else语句

4.for循环

5.while循环

6.break和continue语句

7.列表，元组，字典

8.字符串

9.集合

10.文件操作

 

引言：在我们学习任一门编程语言时，写的第一行代码当然是打印hello world了，我们来看看python是如何实现hello world程序的。

 print("Hello world!") 

python是一种解释型语言，而我们熟知的c语言c++语言等是编译型语言。

编译和解释的区别：    

编译器是把源程序的每一条语句都编译成机器语言,并保存成二进制文件,这样运行时计算机可以直接以机器语言来运行此程序,速度很快; 

解释器则是只在执行程序时,才一条一条的解释成机器语言给计算机来执行,所以运行速度是不如编译后的程序运行的快的。

编译型vs解释型优缺点比较：

编译型
优点：编译器一般会有预编译的过程对代码进行优化。因为编译只做一次，运行时不需要编译，所以编译型语言的程序执行效率高。可以脱离语言环境独立运行。
缺点：编译之后如果需要修改就需要整个模块重新编译。编译的时候根据对应的运行环境生成机器码，不同的操作系统之间移植就会有问题，需要根据运行的操作系统环境编译不同的可执行文件。

解释型
优点：有良好的平台兼容性，在任何环境中都可以运行，前提是安装了解释器（虚拟机）。灵活，修改代码的时候直接修改就可以，可以快速部署，不用停机维护。

缺点：每次运行的时候都要解释一遍，性能上不如编译型语言。

一、变量

声明变量

 name=“cola” 

上述代码声明了一个名字为name的变量，变量name的值为cola

变量定义规则：

• 变量名只能是 字母、数字或下划线的任意组合
• 变量名的第一个字符不能是数字
• 以下关键字不能声明为变量名
  ['and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'exec', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'print', 'raise', 'return', 'try', 'while', 'with', 'yield']

 二、用户输入

# 输入你的名字
name=input("Input your name:")
print("Hello"+name)  

很明显，这里输入是明文，而对于登陆界面需要输入密码时，我们常常不希望密码显示出来，那么如何实现密文操作呢？下列代码中，我们使用了password模块中的password方法，

import getpass
name=input("Input your name:")
password=getpass.getpass("Your password:")

三、if...else语句

# 用户登陆验证

import getpass

name=input("Input your name:")
password=getpass.getpass("Your password:")
if name=="cola" and password=="1234":
    print("Welcome back!")
else:
    print("Your password or username is wrong.")

四、for循环

# for 循环
for i in range(10): 
    print("loop: ",i)

　　loop: 0
　　loop: 1
　　loop: 2
　　loop: 3
　　loop: 4
　　loop: 5
　　loop: 6
　　loop: 7
　　loop: 8
　　loop: 9

五、while循环

#while 循环
1 count=0 
while True: 
    print("count")

六、break和continue语句

# break
for i in range(10)：
    if i > 5:
        break5     print(i)

这里当i的值小于5时，输出显示i，当i等于5时跳出循环并结束循环。

 # continue
 for i in range(10)：
      if i < 5:
          continue
      print(i)

当i的值小于5时，跳出本次循环，进行下次循环，所以最后的结果是打印了5到9的数字。

七、列表，元组，字典

1.列表

列表的定义格式：

list=["处处吻","野孩子","小城大事","烈女"]

列表操作：切片、追加、插入、修改、删除、扩展、拷贝、统计、排序、翻转、获取下标

# 切片

list=["郑中基","杨千嬅","陈奕迅"，“谢安琪”]
print(list[1:3]) #取下标1到下标3之间的数字，包括1，但不包括3
运行结果：["杨千嬅","陈奕迅"]
print(list[1:-1]) #取下标1至-1的值，不包括-1
运行结果：["杨千嬅","陈奕迅"]
print(list[0:3]) 
运行结果：["郑中基","杨千嬅","陈奕迅"]
print(list[:3]) #如果是从头开始取，0可以忽略，跟上句效果一样
运行结果：["郑中基","杨千嬅","陈奕迅"]
print(list[2:]) #如果想取最后一个，必须不能写-1，只能这么写
运行结果：["陈奕迅"，“谢安琪”] 
print(list[2:-1]) #这样-1就不会被包含了
运行结果：["陈奕迅"]
print(list[0::2]) #后面的2是代表，每隔一个元素，就取一个
运行结果：["郑中基","陈奕迅"] 
print(list[::2]) #和上句效果一样
运行结果：["郑中基","陈奕迅"]

# 追加

list=["郑中基","杨千嬅","陈奕迅","谢安琪"]
list.append("周柏豪")
print(list)
运行结果：["郑中基","杨千嬅","陈奕迅","谢安琪","周柏豪"]

# 插入

list=["郑中基","杨千嬅","陈奕迅","谢安琪"]
list.insert(2,"在陈奕迅后面插入")
print(list)
运行结果：["郑中基","杨千嬅","陈奕迅","在陈奕迅后面插入","谢安琪"]

# 修改

list=["郑中基","杨千嬅","陈奕迅","在陈奕迅后面插入","谢安琪"]
list[3]="薛凯琪"
print(list)
运行结果：["郑中基","杨千嬅","陈奕迅","薛凯琪","谢安琪"]

# 删除

list=["郑中基","杨千嬅","陈奕迅","从陈奕迅后面插入","谢安琪"]
del list[3]
print(list)
运行结果：["郑中基","杨千嬅","陈奕迅","谢安琪"]
# remove删除指定元素
list.remove("陈奕迅")
print(list)
运行结果：["郑中基","杨千嬅","谢安琪"]
# pop删除列表最后一个元素
list.pop()
print(list)
运行结果：["郑中基","杨千嬅"]

# 扩展

list=["郑中基","杨千嬅","陈奕迅","谢安琪"]
list2=["周柏豪","侧田"]
list.extend(list2)
print(list)
运行结果：["郑中基","杨千嬅","陈奕迅","谢安琪","周柏豪","侧田"]

# 拷贝

list=["郑中基","杨千嬅","陈奕迅","谢安琪"]
list_copy=list.copy()
print(list_copy)
运行结果：["郑中基","杨千嬅","陈奕迅","谢安琪"]

#copy是一种浅copy，当执行下列语句时，
list=["郑中基","杨千嬅",["陈奕迅","测试copy"],"谢安琪"]
list_copy=list.copy()
print("修改前：",list)
print("修改前：",list_copy)
list[1]="修改"
print(list)
print(list_copy)
运行结果：
修改前： ['郑中基', '杨千嬅', ['陈奕迅', '测试copy'], '谢安琪']
修改前： ['郑中基', '杨千嬅', ['陈奕迅', '测试copy'], '谢安琪']
['郑中基', '修改', ['陈奕迅', '测试copy'], '谢安琪']
['郑中基', '杨千嬅', ['陈奕迅', '测试copy'], '谢安琪']

# 如果我们来修改列表中嵌套的那个列表中的某个元素时，
list=["郑中基","杨千嬅",["陈奕迅","测试copy"],"谢安琪"]
list_copy=list.copy()
print("修改前：",list)
print("修改前：",list_copy)
list[2][1]="修改"
print(list)
print(list_copy)
运行结果：
修改前： ['郑中基', '杨千嬅', ['陈奕迅', '测试copy'], '谢安琪']
修改前： ['郑中基', '杨千嬅', ['陈奕迅', '测试copy'], '谢安琪']
['郑中基', '杨千嬅', ['陈奕迅', '修改'], '谢安琪']
['郑中基', '杨千嬅', ['陈奕迅', '修改'], '谢安琪']

对于上述这种copy，举个例子说明一下他的用处。比如：一对夫妻共用一个银行账号，要求两个人可以使用各自的名字登陆、操作。对于嵌套的列表，我们可以把他当作是夫妻的存款，这种方法就可以使得当男/女任一方消费金额时都可以达到嵌套列表值修改的效果。

# 统计

list=["郑中基","杨千嬅","陈奕迅","陈奕迅"],"谢安琪"]
print(list.count("陈奕迅"))
运行结果：2     
# 统计的是列表中某个元素的个数，所以count的参数为列表元素值

# 排序

list=["郑中基","杨千嬅","陈奕迅","谢安琪"]
list.sort()
print(list)
运行结果：['杨千嬅', '谢安琪', '郑中基', '陈奕迅']
这里具体按什么排序我也不知道，可能是编码吧！
再看下面一种情况，

list=["郑中基","杨千嬅","陈奕迅","谢安琪",1,2,3]
如果list中既有字符串也有数字，这时运行程序会出现如下错误：
    TypeError: unorderable types: int() < str()
#这是因为在3.0中不同数据类型布恩那个放在一起排序

对于纯数字列表，
list=[3,2,4,6,6,3]
list.sort()
print(list)
运行结果：[2, 3, 3, 4, 6, 6]，这里是按数字由小到大排序的

再来看这种情况，
list=["郑中基","杨千嬅","陈奕迅","谢安琪","1","2","3"]
list.sort()
print(list)
运行结果：['1', '2', '3', '杨千嬅', '谢安琪', '郑中基', '陈奕迅']

# 反转

list=["郑中基","杨千嬅","陈奕迅","谢安琪"]
list.reverse()
print(list)
运行结果：['谢安琪', '陈奕迅', '杨千嬅', '郑中基']

# 获取下标

list=["郑中基","杨千嬅","陈奕迅","谢安琪"]
print(list.index("郑中基"))
运行结果：0
#需要注意的的时，index()只返回找到的第一个下标

2.元组：不可修改的列表（只读列表），只有两个操作（count，index）

这里只说明一点，元组是用小括号，而列表则是中括号。

tuple=("处处吻","野孩子","小城大事","烈女")
list=["处处吻","野孩子","小城大事","烈女"]

3.字典

字典是一种key-value的数据类型，我们上学时使用字典的方法是通过拼音或者偏旁部首来查某个字词，python中的字典也是如此，通过key来获取value的。

字典的定义格式：

song_list={
        "1001":"处处吻",
        "1002":"小城大事",
        "1003":"烈女",          
}

需要注意的是：

1. 字典是无序的
2. 字典的key是唯一的

字典操作：增加、修改、删除、查找、多级字典嵌套、循环字典、其他操作

# 增加

song_list={
        "1001":"处处吻",
        "1002":"小城大事",
        "1003":"烈女",
}
print(song_list)
song_list["1004"]="野孩子"
print(song_list)
运行结果：
{'1002': '小城大事', '1003': '烈女', '1001': '处处吻'}
{'1002': '小城大事', '1003': '烈女', '1001': '处处吻', '1004': '野孩子'}

#修改

song_list={
        "1001":"处处吻",
        "1002":"小城大事",
        "1003":"烈女",
}
print(song_list)
song_list["1003"]="野孩子"
print(song_list)
运行结果：
{'1001': '处处吻', '1002': '小城大事', '1003': '烈女'}
{'1001': '处处吻', '1002': '小城大事', '1003': '野孩子'}

# 删除

#第一种删除方式
song_list={
        "1001":"处处吻",
        "1002":"小城大事",
        "1003":"烈女",
}
print(song_list)
song_list.pop("1002")
print(song_list)
运行结果：
{'1001': '处处吻', '1002': '小城大事', '1003': '烈女'}
{'1001': '处处吻', '1003': '烈女'}

#第二种删除方式
song_list={
        "1001":"处处吻",
        "1002":"小城大事",
        "1003":"烈女",
}
print(song_list)
del song_list["1002"]
print(song_list)
运行结果同上

#随机删除 popitem
song_list={
        "1001":"处处吻",
        "1002":"小城大事",
        "1003":"烈女",
}
print(song_list)
song_list.popitem()
print(song_list)
运行结果为随机删除一个key-value

# 查找

song_list={
        "1001":"处处吻",
        "1002":"小城大事",
        "1003":"烈女",
}
print("1001" in song_list)
运行结果： True

song_list={
        "1001":"处处吻",
        "1002":"小城大事",
        "1003":"烈女",
}
print(song_list.get("1001"))
运行结果：处处吻

song_list={
        "1001":"处处吻",
        "1002":"小城大事",
        "1003":"烈女",
}
print(song_list["1001"])
运行结果同上，但是当需要查找的这个key不在字典中是，这种方式会报错KeyError: ，而get不会，不存在将返回None

# 多级字典嵌套
 
catalog={
    "大陆":{
        "刘欢":"北京欢迎您",
        "韩红":"天路",
        "孙楠":"哪吒传奇"
     },
    "台湾":{
        "周杰伦":"蜗牛",
        "罗志祥":"爱不单行",
        "邓丽君":"甜蜜蜜"
     },
    "香港":{
        "陈奕迅伦":"十年",
        "郑中基":"无赖",
        "杨千嬅":"可惜我是水瓶座"
     },
}
print(catalog)
catalog["香港"]["杨千嬅"]+=",野孩子"
print(catalog["香港"]["杨千嬅"])
运行结果：{'大陆': {'刘欢': '北京欢迎您', '孙楠': '哪吒传奇', '韩红': '天路'}, '香港': {'郑中基': '无赖', '陈奕迅伦': '十年', '杨千嬅': '可惜我是水瓶座'}, '台湾': {'邓丽君': '甜蜜蜜', '周杰伦': '蜗牛', '罗志祥': '爱不单行'}}
可惜我是水瓶座,野孩子

# 循环字典

dic={
    "1001":"吃饭",
    "1002":"睡觉",
    "1003":"写代码"
}
#方法一
for key in dic:
    print(key,dic[key])
运行结果：
      1001 吃饭
      1003 写代码
      1002 睡觉   

#方法二
for k,v in dic.items():
    print(k,v)
 # 这里首先把dict转换成list，数据大时不要用
print(dic.items())
>>>dict_items([('1001', '吃饭'), ('1003', '写代码'), ('1002', '睡觉')])

dic={
    "1001":"吃饭",
    "1002":"睡觉",
    "1003":"写代码"
}

# values
print(dic.values())
>>>dict_values(['写代码', '睡觉', '吃饭'])

#keys
print(dic.keys())
>>>dict_keys(['1003', '1002', '1001'])

#items
print(dic.items())
>>>dict_items([('1001', '吃饭'), ('1003', '写代码'), ('1002', '睡觉')])

#setdefault  如果原字典中没有参数中这个key就添加一项，有key无影响
dic.setdefault("1004","eat")
print(dic)
>>>{'1004': 'eat', '1001': '吃饭', '1002': '睡觉', '1003': '写代码'}
dic.setdefault("1001","eat")
print(dic)
>>>{'1003': '写代码', '1002': '睡觉', '1001': '吃饭'}

#update
b={
    1:2,
    2:3
}
dic.update(b)
print(dic)
>>>{'1001': '吃饭', 1: 2, '1003': '写代码', '1002': '睡觉', 2: 3}

#通过一个列表生成默认dict,有个没办法解释的坑,少用
dict.fromkeys([1,2,3],'testd')
>>> {1: 'testd', 2: 'testd', 3: 'testd'}

八、字符串

1.字符串拼接

三种方法：万恶的+，使用占位符，format两个格式

# 万恶的加号

information='''-------information of '''+name+'''-------
name:'''+name+'''
age:'''+age
print(information)

# 使用占位符

information='''
-----------information of %s
name:%s
age:%d
'''%(name,name,age)
print(information)

# format的两种格式

information='''
-----------information of {_name}
name:{_name}
age:{_age}
'''.format(_name=name,_age=age)
print(information)

information='''
-----------information of {0}
name:{0}
age:{1}
'''.format(name,age)
print(information)

2.字符串操作

name="i \tdrink {cola}"
print(name.capitalize())         #首字母大写
print(name.count("a"))           #a的个数
print(name.center(50,"-"))       #共打印50个字符（name居中），不够用-表示
print(name.encode(encoding="utf-8"))
print(name.endswith("b"))        #判断字符串是否以b结尾，返回布尔值
print(name.expandtabs(30))       #tab即\t占30字符
print(name[name.find("drink"):]) #切片
print(name.format(cola="cola"))    >>>i     drink cola
print(name.format_map({"cola":"cola"}))
print(name.isalnum())            #判断是否为数字
print("abc22tt".isalnum()) 
print("abc2".isalpha())          #判断是否为字母
print("abc".isalpha())
print("1".isdecimal())           #判断是否为十进制
print("1a".isdecimal())
print("a1a".isidentifier())      #判断是否为一个合法的标识符
print("aaa".islower())           #判断是否为小写
print("AAA".isupper())           #判断是否为大写
print("  ".isspace())            #判断是否为空格
print("We Love You".istitle())   
print("mmm".isprintable())
print("+".join(["1","2","3"]))   >>>1+2+3
print(name.ljust(50,"*"))        #左边用*补齐50字符
print(name.rjust(50,"*"))
print("ALEX".lower())            #小写
print("alex".upper())

print("   alex   \n")            #去除换行符和空格
print("   alex   \n".strip())
print("   alex   \n".lstrip())
print("   alex   \n".rstrip())

name.partition("i")              #将name字符串按照i进行划分，返回一个元组

p=str.maketrans("abc","123")     #abc分别对应123
print("cola".translate(p))       #将cola中的字符按abc对应123进行转化

print("cola cola".replace("c","C",1))      #"c"换成"C"，换一个
print("cola cola".rfind("l"))              #找右边l的位置
print("cola cola Cola".split("l"))         #把字符串变换为列表，默认按空格分
print("cola\ncola\nCola".splitlines())   >>>['cola', 'cola', 'Cola']
print("cola".swapcase())         #大小写互换
print("cola cola".title())   
print("cola".zfill(50))          #前面用0补足50个字符

九、集合

集合特点：无序，不重复 ------->>>去重、关系测试（交差并）

s=set("hello world")   #创建一个字符集合

t=set([1,2,3,4,2])      #创建一个数字集合

#关系操作
a = t | s          # t 和 s的并集  
  
b = t & s          # t 和 s的交集  
  
c = t – s          # 求差集（项在t中，但不在s中）  
  
d = t ^ s          # 对称差集（项在t或s中，但不会同时出现在二者中） 

list1 = [1,4,5,7,3,1,4]
list1 = set(list1)
list2 = set([2,6,3,2,4,6])
# print(list1,type(list1))
print(list1,list2)

# 交集  intersection
print("------交集-------")
print(list1.intersection(list2))
print(list1 & list2)
# 并集  union
print("------并集-------")
print(list1.union(list2))
print(list1 | list2)
# 差集  difference
print("------差集-------")
print(list1.difference(list2))
print(list1 - list2)
# 子集父集  subset和superset
print("------子集-------")
print(list2.issubset(list1))
print(list2.issuperset(list1))
# 对称差集 symmetric_difference
print("------对称差集-------")
print(list1.symmetric_difference(list2))
print(list1 ^ list2)
print("-----------------")
print(list1.isdisjoint(list2))

# 集合增删改查

list= [1, 2, 2, 3, 4]
list= set(list)
print( list )
list.add(5)
print( list )
list.update([9,8,7])
print( list )
list.remove(9)
print( list )
print(len(list))
list.remove(2)
print( list )
print(2 in list)
print(2 not in list)
print(list.pop())   # 删除第一个 
print(list.discard(4))

十、文件操作

文件操作流程

1. 打开文件，得到文件句柄并赋值给一个变量
2. 通过句柄对文件进行操作
3. 关闭文件

打开文件的模式有：

• r，只读模式（默认）。
• w，只写模式。【不可读；不存在则创建；存在则删除内容；】
• a，追加模式。【可读；   不存在则创建；存在则只追加内容；】

"+" 表示可以同时读写某个文件

• r+，可读写文件。【可读；可写；可追加】
• w+，写读
• a+，同a

"U"表示在读取时，可以将 \r \n \r\n自动转换成 \n （与 r 或 r+ 模式同使用）

• rU
• r+U

"b"表示处理二进制文件（如：FTP发送上传ISO镜像文件，linux可忽略，windows处理二进制文件时需标注）

• rb
• wb
• ab

文件操作，读取一行：

f.readline()

对文件进行读操作时，可以通过tell()和seek()语句来操作读文件的光标位置。

在w模式下进行操作时，会把原来文件的内容清空！！！

f.trunate()  # 清空文件
f.truncate(10) # 从文件开头开始截断,seek无效

对于文件修改，我们可以通过新建一个新的文件来实现，如下：

f=open("cola","r")
f_new=open("cola_new","w")
for line in f:
    if "可否有另一个我在你身边给予快乐" in line:
        line=line.replace("可否有另一个我在你身边给予快乐","可否有另一个我在你身边给予快乐__赵浴辰")
    f_new.write(line)
f.close()
f_new.close()

通过flush语句来实现进度条：

import sys,time

for i in range(50):
    sys.stdout.write("#")
    sys.stdout.flush()
    time.sleep(0.5)

sys模块中的sys.stdout.write方法可以实现不换行打印，sleep方法实现延时的。

 

注：学习了几天python，想要把这些基础的语法记录下来，以便自己记忆和后续学习。

参考博客：金角大王等唐僧的日子http://www.cnblogs.com/alex3714/