【Python之路】—— 基础部分

输入和输出

a = input()：用户从电脑输入一些字符，放到a中
a是一个变量，随便起什么名字都可以

print():
在括号中加上字符串，就可以向屏幕上输出指定的文字
print("这里写字符串")

接受多个字符串，用逗号“,”隔开，就可以连成一串输出
print("this","is","python")

缩进

tab : 4个空格

数据类型和变量

整数：任意大小的整数。无大小限制，整数运算永远是精确。

浮点数：小数。写法：数学写法，如1.23，3.14；科学计数法：1.23x10^9在程序中写成1.23e9，浮点数运算则可能会有四舍五入的误差

字符串：以单引号‘或双引号"括起来的任意文本。

布尔值：True,False。首字母大写。运算：and、or、not

空值：None

变量: 程序中就是用一个变量名，变量名必须是大小写英文、数字和_的组合，且不能用数字开头。

常量：全部大写的变量名表示常量，如PI=3.14159265359

注意：

在Python中，等号=是赋值语句，可以把任意数据类型赋值给变量，同一个变量可以反复赋值，而且可以是不同类型的变量，例如：

a = 123 # a是整数
print(a)
a = 'ABC' # a变为字符串
print(a)

这种变量本身类型不固定的语言称之为动态语言，与之对应的是静态语言。静态语言在定义变量时必须指定变量类型，如果赋值的时候类型不匹配，就会报错。例如Java是静态语言，赋值语句如下（// 表示注释）：

int a = 123; // a是整数类型变量
a = "ABC"; // 错误：不能把字符串赋给整型变量

总结：

/：

10 / 3  # 3.3333333333333335

/除法计算结果是浮点数，即使是两个整数恰好整除，结果也是浮点数：

//:称为地板除,整数的地板除//永远是整数，即使除不尽。

10 // 3 # 3

余数运算%，可以得到两个整数相除的余数：

10 % 3 # 1

编码

历史简介

ASCII编码：由于计算机是美国人发明的，因此，最早只有127个字母被编码到计算机里，也就是大小写英文字母、数字和一些符号，比如大写字母A的编码是65，小写字母z的编码是122。

Unicode编码：Unicode把所有语言都统一到一套编码里，解决各国编码方式不一样造成的乱码问题。但是存储空间大大；

UTF-8编码：一个Unicode字符根据不同的数字大小编码成1-6个字节，常用的英文字母被编码成1个字节，汉字通常是3个字节，只有很生僻的字符才会被编码成4-6个字节。

节省空间。

ASCII编码实际上可以被看成是UTF-8编码的一部分

写文件的编码转换过程

内存中使用Unicode编码，当需要保存到硬盘或者需要传输的时候，就转换为UTF-8编码。

用记事本编辑的时候，

读：UTF-8==>Unicode。硬盘到内存

保存：Unicode==>UTF-8。内存到硬盘

字符串

Python 3的字符串使用Unicode，直接支持多语言。

特性：不可修改

相关方法

ord()函数获取字符的整数表示

chr()函数把编码转换为对应的字符

>>> ord('A')
65
>>> ord('中')
20013

len()：计算字符串长度

name.capitalize()  首字母大写
name.casefold()   大写全部变小写
name.center(50,"-")  输出 '---------------------Alex Li----------------------'
name.count('lex') 统计 lex出现次数
name.encode()  将字符串编码成bytes格式
name.endswith("Li")  判断字符串是否以 Li结尾
 "Alex\tLi".expandtabs(10) 输出'Alex      Li'， 将\t转换成多长的空格
 name.find('A')  查找A,找到返回其索引， 找不到返回-1 

msg.index('a')  返回a所在字符串的索引
'9aA'.isalnum()   True

'9'.isdigit() 是否整数
name.isnumeric
name.isprintable
name.isspace
name.istitle
name.isupper
 "|".join(['alex','jack','rain'])
'alex|jack|rain'

maketrans
    >>> intab = "aeiou"  #This is the string having actual characters.
    >>> outtab = "12345" #This is the string having corresponding mapping character
    >>> trantab = str.maketrans(intab, outtab)
    >>>
    >>> str = "this is string example....wow!!!"
    >>> str.translate(trantab)
    'th3s 3s str3ng 2x1mpl2....w4w!!!'

 msg.partition('is')   输出 ('my name ', 'is', ' {name}, and age is {age}') 

 >>> "alex li, chinese name is lijie".replace("li","LI",1)
     'alex LI, chinese name is lijie'

 msg.swapcase 大小写互换

 >>> msg.zfill(40)
'00000my name is {name}, and age is {age}'

>>> n4.ljust(40,"-")
'Hello 2orld-----------------------------'
>>> n4.rjust(40,"-")
'-----------------------------Hello 2orld'

>>> b="ddefdsdff_哈哈"
>>> b.isidentifier() #检测一段字符串可否被当作标志符，即是否符合变量命名规则
True

格式化

%d 整数
%f 浮点数
%s 字符串
%x 十六进制整数

%s把任何数据类型转换为字符串

字符串格式化符：.format

print("{} is eating {}.".format('benjie','meat'))
print("{a} is eating {b}.".format(a = 'benjie',b = 'meat'))
print('{0} is eating {1}.'.format('benjie','meat'))

str到byte的转换

由于Python的字符串类型是str，在内存中以Unicode表示，一个字符对应若干个字节。如果要在网络上传输，或者保存到磁盘上，就需要把str变为以字节为单位的bytes

bytes类型：带b前缀的单引号或双引号表示：

x = b'ABC'

"字符串".encode()： 字符串到bytes

b"字节".decode()：bytes到字符串

1个中文字符经过UTF-8编码后通常会占用3个字节，而1个英文字符只占用1个字节。

由于Python源代码也是一个文本文件，所以，当你的源代码中包含中文的时候，在保存源代码时，就需要务必指定保存为UTF-8编码。当Python解释器读取源代码时，为了让它按UTF-8编码读取，我们通常在文件开头写上这两行：

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

第一行注释是为了告诉Linux/OS X系统，这是一个Python可执行程序，Windows系统会忽略这个注释；

第二行注释是为了告诉Python解释器，按照UTF-8编码读取源代码，否则，你在源代码中写的中文输出可能会有乱码。

列表、集合、字典

列表（list）

特性：有序

  • 访问列表中元素：list[index],索引是从0开始的：

    names = ['benjie','jack','alex']
print(names[0])  # benjie
print(names[1])  # jack
print(names[2])  # alex
# print(names[3])# IndexError: list index out of range
  • 切片
    >>> names = ["Alex","Tenglan","Eric","Rain","Tom","Amy"]
>>> names[1:4]  #取下标1至下标4之间的数字，包括1，不包括4
['Tenglan', 'Eric', 'Rain']
>>> names[1:-1] #取下标1至-1的值，不包括-1
['Tenglan', 'Eric', 'Rain', 'Tom']
>>> names[0:3]
['Alex', 'Tenglan', 'Eric']
>>> names[:3] #如果是从头开始取，0可以忽略，跟上句效果一样
['Alex', 'Tenglan', 'Eric']
>>> names[3:] #如果想取最后一个，必须不能写-1，只能这么写
['Rain', 'Tom', 'Amy']
>>> names[3:-1] #这样-1就不会被包含了
['Rain', 'Tom']
>>> names[0::2] #后面的2是代表，每隔一个元素，就取一个
['Alex', 'Eric', 'Tom']
>>> names[::2] #和上句效果一样
['Alex', 'Eric', 'Tom']
  • 追加
    >>> names = ['Alex', 'Tenglan', 'Eric', 'Rain', 'Tom', 'Amy']
>>> names.append("我是新来的")
>>> names
['Alex', 'Tenglan', 'Eric', 'Rain', 'Tom', 'Amy', '我是新来的']
  • 插入

    insert(index, p_object):

    names = ['benjie','jack','alex']
names.insert(2,"新人")
print(names)  #  ['benjie', 'jack', '新人', 'alex']
  • 删除
    del names[0]  # 删第一个元素['jack', '新人', 'alex']
  • 修改
    names = ['benjie','jack','alex']
names[1] = "新换的" # ['benjie', '新换的', 'alex']
  • 扩展
    L.extend(iterable) -> None -- extend list by appending elements from the iterable
  • 拷贝
    names = ['benjie', 'jack', 'alex']
name_copy = names.copy()
print(name_copy) #  ['benjie', 'jack', 'alex']
  • 统计
    L.count(value) -> integer -- return number of occurrences of value
  • 排序和翻转
    >>> names
['Alex', 'Tenglan', 'Amy', 'Tom', 'Amy', 1, 2, 3]
>>> names.sort() #排序
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unorderable types: int() < str()   #3.0里不同数据类型不能放在一起排序了，擦
>>> names[-3] = '1'
>>> names[-2] = '2'
>>> names[-1] = '3'
>>> names
['Alex', 'Amy', 'Amy', 'Tenglan', 'Tom', '1', '2', '3']
>>> names.sort()
>>> names
['1', '2', '3', 'Alex', 'Amy', 'Amy', 'Tenglan', 'Tom']

>>> names.reverse() #反转
>>> names
['Tom', 'Tenglan', 'Amy', 'Amy', 'Alex', '3', '2', '1']
  • 获取下标
    names = ['Tom', 'Tenglan', 'Amy', 'Amy', 'Alex', '3', '2', '1']
>>> names.index("Amy")
2 #只返回找到的第一个下标

元组（tuple）

只读列表。有序

特性：一旦创建不能修改。元组用来存放一些希望不被改变的值.

两个方法：count，index

tuple_test = ("alex","ben","alex","benjie")
print(tuple_test.index("alex"))  # 0  获取该元素第一次出现的位置
print(tuple_test.count("alex"))  # 2

集合（set）

无序，元素不重复。

s = set([1, 2, 3])
>>> s
{1, 2, 3}

传入的参数[1, 2, 3]是一个list，而显示的{1, 2, 3}只是告诉你这个set内部有1，2，3这3个元素，显示的顺序也不表示set是有序的。。

特性：

  1. 去重
  2. 关系测试：交集，差集，并集等
# -*- coding: utf-8 -*-
# Author:benjamin
# Date: 3.3

'''
list_1 = [1,4,5,7,6,7,8,3]
list_1 = set(list_1)
list_2 = set([2,5,6,0,66,22,8])
print(list_1 | list_2)#并
print(list_1 & list_2)#交
print(list_1 - list_2)#差集
print(list_1 ^ list_2)#对称差集
'''

list_1 = [10,7,5,7,6,7,8,3,2]
list_1 = set(list_1)
# 打印集合，自动去重；
print(list_1,type(list_1))
# {2, 3, 5, 6, 7, 8, 10} <class 'set'>

# 无序
list_2 = set([2,5,6,0,66,22,8])
print(list_1,list_2)
# {2, 3, 5, 6, 7, 8, 10} {0, 2, 66, 5, 6, 8, 22}

# 交集
print(list_1.intersection(list_2))  # {8, 2, 5, 6}

# 并集
print(list_1.union(list_2))  # {0, 2, 3, 66, 5, 6, 7, 8, 10, 22}
# 差集 in list_1 but not in list_2
print(list_1.difference(list_2))  # {10, 3, 7}
# 子集
print('list_1 is subset list-2',list_1.issubset(list_2))  # False
print('list_1 is superset list_2',list_1.issuperset(list_2))  # False

list_3 = set([2,7])
print(list_3.issubset(list_1))  # True
print(list_1.issuperset(list_3))  # True

# 对称差集 返回一个新的 set 包含 list1和 list2中不重复的元素
print(list_1.symmetric_difference(list_2))  # {0, 66, 3, 7, 22, 10}

# Return True if two sets have a null intersection.
print(list_2.isdisjoint(list_3))  # False

# 增
list_1.add(99)
print(list_1)
# 增一组
list_1.update([33,22,56])
print(list_1)  # {33, 2, 3, 99, 5, 6, 7, 8, 10, 22, 56}

# 判断元素是否在集合中，用于条件判断
print('元素在list_1', {3333} in list_1)

print(list_1)  # {33, 2, 3, 99, 5, 6, 7, 8, 10, 22, 56}
print(list_1.pop())  # 33
print(list_1.discard('7'))  # None
print(list_1.discard('ssss'))  # None
print(list_1.remove(8))  # None

字典(dict)

key-value形式，无序，key唯一。

  • 增
  • 删

    要删除一个key，用pop(key)方法，对应的value也会从dict中删除：

  • 改
  • 查
    1. key in dict
2. dict.get(key):方法不存在返回none 推荐使用
  • 插
# -*- coding: utf-8 -*-
# Author:benjamin
# Date:
# 字典是无序的，输出不一定，通过key来取出。
#
info = {
    'n1': '小明',
    'n2': '小红',
    'n3': '小张'
}
info1 = info
# 增
info['n4'] = '小来'
print(info)
# 删
info.pop('n4')
print(info)
# del 删
del info['n2']
print(info)
# 随机删
info.popitem()
print(info)

info = {'n1': '小明', 'n2': '小红', 'n3': '小张'}
# 改
info['n3'] = '呵呵'
print(info)

# 查
print('n3' in info)  # True
print(info.get('n4'))  # None get方法不存在返回none
# print(info['n6'])#Traceback (most recent call last): KeyError: 'n6' key不存在会报错

# 遍历
for i in info:
    print(i, info[i])
# 会先把dict转成list，数据大时莫用
for k, v in info.items():
    print(k, v)

# values
print(info.values())  # dict_values(['小红', '小明', '呵呵'])
# keys
print(info.keys())  # dict_keys(['n2', 'n1', 'n3'])
# setdefault
# D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D
info.setdefault('n10', 'alex')
print(info)

# update
b = {
    1: 2,
    3: 4,
    'stu1101': 'tenglan wu'
}
info.update(b)
print(info)

文件操作

操作流程

  1. 打开文件，得到文件句柄并赋值给一个变量

    文件句柄=open(‘文件路径‘，‘模式’)

  2. 通过句柄对文件进行操作

    read

    readline

  3. 关闭文件

    close

模式

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

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

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

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

  • rU
  • r+U

"b"表示处理二进制文件（如：FTP发送上传ISO镜像文件，linux可忽略，windows处理二进制文件时需标注）b(rb,wb,ab)模式：不用加encoding:utf-8

  • rb
  • wb
  • ab

with语句

为了避免打开文件后忘记关闭，可以通过管理上下文，即：

with open("文件名","打开方式") as f:
    操作

文件修改

import os
with open('a.txt','r',encoding='utf-8') as read_f,        open('a.txt.swap','w',encoding='utf-8') as write_f:
    for line in read_f:
        write_f.write(line)

os.remove('a.txt')
os.rename('.a.txt.swap','a.txt')

参考链接

https://docs.pythontab.com/python/python3.4/index.html

https://www.cnblogs.com/haiyan123/p/8387770.html#lable2

https://www.cnblogs.com/alex3714/articles/5885096.html

原文地址：https://www.cnblogs.com/benjieqiang/p/11407919.html

时间： 2024-08-25 10:27:15

【Python之路】—— 基础部分的相关文章

python之路-基础篇-day3

今日所讲知识点总结: 1.set集合 2.collections Python拥有一些内置的数据类型,比如str, int, list, tuple, dict等, collections模块在这些内置数据类型的基础上,提供了几个额外的数据类型: 1)Counter:计数器 2)OrderedDict:有序字典 3)defaultdict:默认字典 4)namedtuple:可命名元组 5)deque:双向队列 set集合 set集合是一个元素不重复的无序集合.类似于字典的key组成的一个无序集

python之路基础篇

1. Python基础之初识python 2. Python数据类型之字符串 3. Python数据类型之列表 4. Python数据类型之元祖 5. Python数据类型之字典 6. Python Set集合,函数,深入拷贝,浅入拷贝,文件处理 7. Python之常用模块 8. python正则表达式 9. python面向对象编程 10.python之socket编程 11.python进程.线程.协程

菜鸟的Python之路--基础知识

刚刚开始自学Python,整理一下自己的学习感悟 刚刚开始学习Python,代码之路才刚刚开始第一个差距就感受到了.Python的标点符号与其他语言的差别,它每句后面都没有":". 变量的命名规则    1. 要具有描述性    2. 变量名只能_,数字,字母组成,不可以是空格或特殊字符(#?<.,￥$*!~)    3. 不能以中文为变量名    4. 不能以数字开头    5. 保留字符是不能被使用 常量 :不变的量 pie = 3.141592653....     在py

Python之路——基础

Python介绍 Python的创始人为吉多·范罗苏姆(Guido van Rossum).1989年的圣诞节期间,吉多·范罗苏姆为了在阿姆斯特丹打发时间,决心开发一个新的脚本解释程序,作为ABC语言的一种继承. Python崇尚优美.清晰.简单,是一个优秀并广泛使用的语言. Python可以应用于众多领域,如:数据分析.组件集成.网络服务.图像处理.数值计算和科学计算等众多领域.目前业内几乎所有大中型互联网企业都在使用Python,如:Youtube.Dropbox.BT.Quora(中国知乎

python之路-基础篇-day2

基本数据类型 在Python中,一切事物都是对象,对象基于类创建 注:查看对象相关成员的函数有:var,type,dir 基本数据类型主要有: 整数 长整型 浮点型 字符串 列表 元组 字典 set集合 接下来将对以上数据类型进行剖析: 1.整数 int 如:18.73.-100 每一个整数都具备如下功能: class int(object): """ int(x=0) -> integer int(x, base=10) -> integer Convert a

python之路-基础篇-8 循环

python中循环有两种,分别是for循环和while循环,循环可以将序列的数据进行迭代处理: for循环 for循环依次把list.tuple或字符串中的每个元素迭代出来,例如: names = ["zhangcong", "lisanjiang", "pangzhiguo"] for name in names: print name # 执行结果 zhangcong lisanjiang pangzhiguo 所以for x in - 循环

python之路-基础篇-003

[〇]学习环境 操作系统: Mac OS X 10.10.5 python: Python 3.5.1 IDE:PyCharm4.5 [一]列表(LIST): 下面是从help中摘录的一部分常用的方法: #创建列表 list() -> new empty list #追加列表 | append(...) | L.append(object) -> None -- append object to end #清除列表 | clear(...) | L.clear() -> None --

python之路基础-（二）内置函数、函数、装饰器

内置函数 python内置了以下函数,可以根据情况来使用 一.数学相关函数 divmod():取商和余数 >>> divmod(99,10) (9, 9) abs():取绝对值 >>> abs(-10) 10 len():查看序列长度 >>>list = [11,22,33,44] >>>r = len(list) >>>print(r)4 二.功能相关函数chr():在ascii码表中根据数字找出对应的字母 >

python之路-基础篇2

10.if else 流程判断 举例说明1: import getpass  #引用getpass这个模块 _username = "kk" _password = "123456" username = input("username:") password = getpass.getpass("password") #getpass功能是让密码不直接显示成明文 if _username == username and _p

python之路 - 基础1

1.安装windows安装双版本Python2,Python3 下载Python2和Python3https://www.python.org/downloads/ 分别安装两个版本 进入Python3的安装目录后,将Python.exe重命名为Python3.exe,删除脚本文件夹下的pip.exe 添加环境变量 Python3安装后已经默认添加到环境变量中,这里只需要添加Python2的环境变量 添加到PATH中 C:\Python27C:\Python27\Scripts 测试是否成功 在