centos 7 中文乱码问题解决

 centos  centos 7 中文乱码问题解决已关闭评论
6月 082020
 

使用aws的centos ec2, 今天编辑一个文件,发现copy进去的中文字变乱码了,原来需要将默认的en_US.UTF-8编码修改为zh_CN中文编码,操作步骤如下:

1.查看安装中文包:

查看系统是否安装中文语言包 (列出所有可用的公共语言环境的名称,包含有zh_CN)

# locale -a |grep "zh_CN"

没有输出,说明没有安装,输入下面的命令安装:

# yum groupinstall "fonts" -y

安装完成,查看安了哪些中文语言包

# locale -a |grep "zh_CN"
zh_CN
zh_CN.gb18030
zh_CN.gb2312
zh_CN.gbk
zh_CN.utf8

说明系统已安装中文语言包,无需再安装。重要提示,如果按照下面的步骤你的系统仍然无法使用中文,那么请一个一个尝试上面的编码方式。比如把LANG=”zh_CN”修改为LANG=”zh_CN.gb18030″。

2.修改配置文件:

在修改配置文件之前,我们先看看当前系统语言环境:

# echo $LANG
en_US.UTF-8

# locale
LANG=en_US.UTF-8
LC_CTYPE="en_US.UTF-8"
LC_NUMERIC="en_US.UTF-8"
LC_TIME="en_US.UTF-8"
LC_COLLATE="en_US.UTF-8"
LC_MONETARY="en_US.UTF-8"
LC_MESSAGES="en_US.UTF-8"
LC_PAPER="en_US.UTF-8"
LC_NAME="en_US.UTF-8"
LC_ADDRESS="en_US.UTF-8"
LC_TELEPHONE="en_US.UTF-8"
LC_MEASUREMENT="en_US.UTF-8"
LC_IDENTIFICATION="en_US.UTF-8"
LC_ALL=

虽然安装了中文语言包但本机的语言环境并不是中文,需要修改locale.conf配置文件:

# vim /etc/locale.conf
LANG="zh_CN"
# source   /etc/locale.conf

也可以使用命令修改locale.conf配置文件:

#  localectl set-locale LANG=zh_CN

之后查看当前语言环境:

# echo $LANG
zh_CN

# locale
LANG=zh_CN
LC_CTYPE="zh_CN"
LC_NUMERIC="zh_CN"
LC_TIME="zh_CN"
LC_COLLATE="zh_CN"
LC_MONETARY="zh_CN"
LC_MESSAGES="zh_CN"
LC_PAPER="zh_CN"
LC_NAME="zh_CN"
LC_ADDRESS="zh_CN"
LC_TELEPHONE="zh_CN"
LC_MEASUREMENT="zh_CN"
LC_IDENTIFICATION="zh_CN"
LC_ALL=

3. 验证是否成功:

[[email protected] ~]# date
2020年 06月 08日 星期一 11:26:03 CST

python 2中希望使用print时将\uxxxx的文字打印为中文

 python  python 2中希望使用print时将\uxxxx的文字打印为中文已关闭评论
5月 092020
 

在python 2里使用print打印含有\uxxx的中文字符时不能直接显示中文,可以使用下面的方式:

举例:

obj = [u’\u53c8\u6765\u5077\u5077\u770b\u6211′,u’\u7231\u6211\u4f60\u5c31\u544a\u8bc9\u6211′]

使用: print(repr(obj).decode(‘unicode-escape’))

 

obj=[‘又来偷偷看我’,’爱我你就告诉我’]

使用:print(repr(obj).decode(‘string-escape’))

 

python 3 没有这个问题

SQLAlchemy Tutorial 使用文档中文版

 python  SQLAlchemy Tutorial 使用文档中文版已关闭评论
1月 152018
 

原文链接:http://www.cnblogs.com/iwangzc/p/4112078.htmlsqlalchemy 官方文档:http://docs.sqlalchemy.org/en/latest/contents.html

1.版本检查

import sqlalchemy
sqlalchemy.__version__  

2.连接

from sqlalchemy import create_engine
engine = create_engine('sqlite:///:memory:',echo=True)

echo参数为True时,会显示每条执行的SQL语句,可以关闭。create_engine()返回一个Engine的实例,并且它表示通过数据库语法处理细节的核心接口,在这种情况下,数据库语法将会被解释称Python的类方法。

3.声明映像

当使用ORM1】时,构造进程首先描述数据库的表,然后定义我们用来映射那些表的类。在现版本的SQLAlchemy中,这两个任务通常一起执行,通过使用Declarative方法,我们可以创建一些包含描述要被映射的实际数据库表的准则的映射类。

使用Declarative方法定义的映射类依据一个基类,这个基类是维系类和数据表关系的目录——我们所说的Declarative base class。在一个普通的模块入口中,应用通常只需要有一个base的实例。我们通过declarative_base()功能创建一个基类:

from sqlalchemy.ext.declarativeimportdeclarative_base
Base = declarative_base()

有了这个base,我们可以依据这个base定义任意数量的映射类。一个简单的user例子:

from sqlalchemy import Column, Integer, String
class User(Base):
__tablename__= 'users'
id= Column(Integer, primary_key=True)
name = Column(String)

Declarative构造的一个类至少需要一个__tablename__属性,一个主键行。

4.构造模式(项目中没用到)

5.创建映射类的实例

ed_user = User(name='ed',fullname='Ed Jones', password='edspassword')

6.创建会话

现在我们已经准备毫和数据库开始会话了。ORM通过Session与数据库建立连接的。当应用第一次载入时,我们定义一个Session类(声明create_engine()的同时),这个Session类为新的Session对象提供工厂服务。

from sqlalchemy.orm import sessionmaker
Session = sessionmaker(bind=engine)

这个定制的Session类会创建绑定到数据库的Session对象。如果需要和数据库建立连接,只需要实例化一个Session

session = Session()

虽然上面的Session已经和数据库引擎Engine关联,但是还没有打开任何连接。当它第一次被使用时,就会从Engine维护的一个连接池中检索是否存在连接,如果存在便会保持连接知道我们提交所有更改并且/或者关闭session对象。

7.添加新对象(简略)

ed_user = User(name='ed', fullname='Ed Jones', password='edspassword')
session.add(ed_user)

至此,我们可以认为,新添加的这个对象实例仍在等待中;ed_user对象现在并不代表数据库中的一行数据。直到使用flush进程,Session才会让SQL保持连接。如果查询这条数据的话,所有等待信息会被第一时间刷新,查询结果也会立即发行。

session.commit()

通过commit()可以提交所有剩余的更改到数据库。

8.回滚

session.rollback()

9.查询

通过Sessionquery()方法创建一个查询对象。这个函数的参数数量是可变的,参数可以是任何类或者是类的描述的集合。下面是一个迭代输出User类的例子:

for instance in session.query(User).order_by(User.id): 
print instance.name,instance.fullname

Query也支持ORM描述作为参数。任何时候,多个类的实体或者是基于列的实体表达都可以作为query()函数的参数,返回类型是元组:

for name, fullname in session.query(User.name,User.fullname): print name, fullname

Query返回的元组被命名为KeyedTuple类的实例元组。并且可以把它当成一个普通的Python数据类操作。元组的名字就相当于属性的属性名,类的类名一样。

 for row in session.query(User, User.name).all(): print row.User,row.name
<User(name='ed',fullname='Ed Jones', password='f8s7ccs')>ed

label()不知道怎么解释,看下例子就明白了。相当于row.name

for row in session.query(User.name.label('name_label')).all(): print(row.name_label) 

aliased()我的理解是类的别名,如果有多个实体都要查询一个类,可以用aliased()

from sqlalchemy.orm import aliased
user_alias = aliased(User, name='user_alias')
for row in session.query(user_alias,user_alias.name).all(): print row.user_alias

Query的 基本操作包括LIMITOFFSET,使用Python数组切片和ORDERBY结合可以让操作变得很方便。

for u in session.query(User).order_by(User.id)[1:3]: #只查询第二条和第三条数据 

9.1使用关键字变量过滤查询结果,filter 和 filter_by都适用。【2】使用很简单,下面列出几个常用的操作

query.filter(User.name == 'ed') #equals
query.filter(User.name != 'ed') #not equals
query.filter(User.name.like('%ed%')) #LIKE
uery.filter(User.name.in_(['ed','wendy', 'jack'])) #IN
query.filter(User.name.in_(session.query(User.name).filter(User.name.like('%ed%'))#IN
query.filter(~User.name.in_(['ed','wendy', 'jack']))#not IN
query.filter(User.name == None)#is None
query.filter(User.name != None)#not None
from sqlalchemy import and_
query.filter(and_(User.name =='ed',User.fullname =='Ed Jones')) # and
query.filter(User.name == 'ed',User.fullname =='Ed Jones') # and
query.filter(User.name == 'ed').filter(User.fullname == 'Ed Jones')# and
from sqlalchemy import or_
query.filter(or_(User.name =='ed', User.name =='wendy')) #or
query.filter(User.name.match('wendy')) #match

9.2.返回列表和数量(标量?)

all()返回一个列表:可以进行Python列表的操作。

query = session.query(User).filter(User.name.like('%ed')).order_by(User.id)
query.all()  
[<User(name='ed',fullname='EdJones', password='f8s7ccs')>,<User(name='fred',
fullname='FredFlinstone', password='blah')>]

first()适用于限制一个情况,返回查询到的第一个结果作为标量?:好像只能作为属性,类

query.first() <User(name='ed',fullname='Ed Jones', password='f8s7ccs')>

one()完全获取所有行,并且如果查询到的不只有一个对象或是有复合行,就会抛出异常。

from sqlalchemy.orm.exc import MultipleResultsFound
user = query.one()
try:  user = query.one()
except MultipleResultsFound, e:
 print e
Multiple rows were found for one()

如果一行也没有:

from sqlalchemy.orm.exc import NoResultFound
try:  user = query.filter(User.id == 99).one()
except NoResultFound, e:
 print e
No row was found for one()

one()方法对于想要解决“no items found”multiple items found”是不同的系统是极好的。(这句有语病啊)例如web服务返回,本来是在no results found情况下返回”404“的,结果在多个results found情况下也会跑出一个应用异常。

scalar()作为one()方法的依据,并且在one()成功基础上返回行的第一列。

query = session.query(User.id).filter(User.name == 'ed')
query.scalar() 7 

9.3.使用字符串SQL

字符串能使Query更加灵活,通过text()构造指定字符串的使用,这种方法可以用在很多方法中,像filter()order_by()

from sqlalchemy import text
for user in session.query(User).filter(text("id<224")).order_by(text("id")).all() 

绑定参数可以指定字符串,用params()方法指定数值。

session.query(User).filter(text("id<:value and name=:name")).\ params(value=224, name='fred').order_by(User.id).one()
 

如果要用一个完整的SQL语句,可以使用from_statement()

ession.query(User).from_statement(text("SELECT* FROM users where name=:name")).\
 params(name='ed').all()

也可以用from_statement()获取完整的”raw”,用字符名确定希望被查询的特定列:

session.query("id","name", "thenumber12").\ from_statement(text("SELECT id, name, 12 as ""thenumber12 FROM users where name=:name")).\

params(name=‘ed’).all()

[(1,u'ed', 12)]
感觉这个不太符合ORM的思想啊。。。

9.4 计数

count()用来统计查询结果的数量。

session.query(User).filter(User.name.like('%ed')).count()  

func.count()方法比count()更高级一点【3

from sqlalchemy import func
 session.query(func.count(User.name),User.name).group_by(User.name).all()  
[(1,u'ed'), (1,u'fred'), (1,u'mary'), (1,u'wendy')]

为了实现简单计数SELECT count(*) FROM table,可以这么写:

session.query(func.count('*')).select_from(User).scalar()  

如果我们明确表达计数是根据User表的主键的话,可以省略select_from(User):

session.query(func.count(User.id)).scalar()  

上面两行结果均为4

Go to (下)


10.建立联系(外键)

是时候考虑怎样映射和查询一个和Users表关联的第二张表了。假设我们系统的用户可以存储任意数量的email地址。我们需要定义一个新表AddressUser相关联。

from sqlalchemyimport ForeignKey from sqlalchemy.ormimport relationship, backref
class Address(Base):
__tablename__ = 'addresses'
id= Column(Integer, primary_key=True)
email_address = Column(String, nullable=False)
user_id = Column(Integer, ForeignKey('users.id'))
user = relationship("User", backref=backref('addresses',order_by=id))
def__repr__(self):
 return"<Address(email_address='%s')>"%self.email_address

构造类和外键简单,就不过多赘述。主要说明以下relationship()函数:这个函数告诉ORMAddress类应该和User类连接起来,通过使用addresses.userrelationship()使用外键明确这两张表的关系。决定Adderess.user属性是多对一的。relationship()的子函数backref()提供表达反向关系的细节:relationship()对象的集合被User.address引用。多对一的反向关系总是一对多。更多的细节参考Basic RelRational Patterns

这两个互补关系:Address.userUser.addresses被称为双向关系。这是SQLAlchemy ORM的一个非常关键的功能。更多关系backref的细节参见Linking Relationships with Backref

假设声明的方法已经开始使用,relationship()中和其他类关联的参数可以通过strings指定。在上文的User类中,一旦所有映射成功,为了产生实际的参数,这些字符串会被当做Python的表达式。下面是一个在User类中创建双向联系的例子:

class User(Base):
addresses = relationship("Address", order_by="Address.id", backref="user")

一些知识:

在大多数的外键约束(尽管不是所有的)关系数据库只能链接到一个主键列,或具有唯一约束的列。

外键约束如果是指向多个列的主键,并且它本身也具有多列,这种被称为“复合外键”。

外键列可以自动更新自己来相应它所引用的行或者列。这被称为级联,是一种建立在关系数据库的功能

外键可以参考自己的表格。这种被称为“自引”外键。

我们需要在数据库中创建一个addresses表,所以我们会创建另一个元数据,这将会跳过已经创建的表。

11.操作主外键关联的对象

现在我们已经在User类中创建了一个空的addresser集合,可变集合类型,例如setdict,都可以用,但是默认的集合类型是list

jack = User(name='jack', fullname='Jack Bean', password='gjffdd')
jack.addresses
[]

现在可以直接在User对象中添加Address对象。只需要指定一个完整的列表:

jack.addresses = [Address(email_address='[email protected]'),Address(email_address='[email protected]')]
当使用双向关系时,元素在一个类中被添加后便会自动在另一个类中添加。这种行为发生在Python的更改事件属性中而不是用SQL语句:
>>> jack.addresses[1]
<Address(email_address='[email protected]')>
>>> jack.addresses[1].user
<User(name='jack', fullname='Jack Bean', password='gjffdd')>
jack提交到数据库中,再次查询Jack,(No SQL is yet issued for Jack’s addresses:)这句实在是翻译不了了,看看代码就明白是什么意思:
>>> jack = session.query(User).\ ...
filter_by(name='jack').one()  
>>> jack
<User(name='jack',fullname='Jack Bean', password='gjffdd')>

>>>jack.addresses  
[<Address(email_address='[email protected]')>, <Address(email_address='[email protected]')>]
当我们访问uaddresses集合时,SQL会被突然执行,这是一个延迟加载(lazy loading)关系的典型例子。现在addresses集合加载完成并且可以像对待普通列表一样对其进行操作。以后我们会优化这种加载方式。
12.使用JOINS查询
现在我们有了两张表,可以进行更多的查询操作,特别是怎样对两张表同时进行查询,Wikipediapage on SQL JOIN提供了很详细的说明,其中一些我们将在这里说明。之前用Query.filter()时,我们已经用过JOIN了,filter是一种简单的隐式join
>>>for u, a in session.query(User, Address).filter(User.id==Address.user_id).filter(Address.email_address=='[email protected]').all(): 
 print u
 print a
<User(name='jack',fullname='JackBean', password='gjffdd')>
<Address(email_address='[email protected]')>
Query.join()方法会更加简单:
>>>session.query(User).join(Address).\
... filter(Address.email_address=='[email protected]').\
... all()  
[<User(name='jack',fullname='JackBean', password='gjffdd')>]
之所以Query.join()知道怎么join两张表是因为它们之间只有一个外键。如果两张表中没有外键或者有一个以上的外键,当下列几种形式使用的时候,Query.join()可以表现的更好:
query.join(Address,User.id==Address.user_id)# 明确的条件
query.join(User.addresses)# 指定从左到右的关系
query.join(Address,User.addresses) #同样,有明确的目标
query.join('addresses') # 同样,使用字符串
 outerjoin()join()用法相同
query.outerjoin(User.addresses)# LEFT OUTER JOIN
12.1使用别名
当在多个表中查询时,如果同一张表需要被引用好几次,SQL通常要求对这个表起一个别名,因此,SQL可以区分对这个表进行的其他操作。Query也支持别名的操作。下面我们joinAddress实体两次,找到同时拥有两个不同email的用户:
>>>from sqlalchemy.ormimport aliased
>>>adalias1 = aliased(Address)
>>>adalias2 = aliased(Address)
>>>for username, email1, email2 in\
... session.query(User.name,adalias1.email_address,adalias2.email_address).\
... join(adalias1, User.addresses).\
... join(adalias2, User.addresses).\
... filter(adalias1.email_address=='[email protected]').\
... filter(adalias2.email_address=='[email protected]'):
... print username, email1,
email2  
jack
jack@google.com j25@yahoo.com
12.1使用子查询(暂时理解不了啊,多看代码研究吧:(
from sqlalchemy.sqlimport func
stmt = session.query(Address.user_id,func.count('*').\
...  label('address_count')).\
...  group_by(Address.user_id).subquery()
>>> for u, count in session.query(User,stmt.c.address_count).\
... outerjoin(stmt, User.id==stmt.c.user_id).order_by(User.id): 
 print u, count
<User(name='ed',fullname='EdJones', password='f8s7ccs')> None
<User(name='wendy',fullname='Wendy Williams', password='foobar')> None
<User(name='mary',fullname='Mary Contrary', password='xxg527')> None
<User(name='fred',fullname='Fred Flinstone', password='blah')> None
<User(name='jack',fullname='Jack Bean', password='gjffdd')> 2
12.2从子查询中选择实体?
上面的代码中我们只返回了包含子查询的一个列的结果。如果想要子查询映射到一个实体的话,使用aliased()设置一个要映射类的子查询别名:
>>> stmt = session.query(Address).\
... filter(Address.email_address!= '[email protected]').\
... subquery()
>>> adalias = aliased(Address, stmt) #?为什么有两个参数?
>>> for user, address in session.query(User, adalias).\
... join(adalias, User.addresses):  
... print user
... print address
<User(name='jack',fullname='Jack Bean', password='gjffdd')>
<Address(email_address='[email protected]')>

12.3使用EXISTS(存在?)

如果表达式返回任何行EXISTS为真,这是一个布尔值。它可以用在jions中,也可以用来定位在一个关系表中没有相应行的情况:

>>>from sqlalchemy.sqlimport exists
>>> stmt = exists().where(Address.user_id==User.id)
>>>for name, in session.query(User.name).filter(stmt): 
 print name
jack

等价于:

>>>for name, in session.query(User.name).\
... filter(User.addresses.any()):  
... print name
jack

any()限制行匹配:

>>>for name, in session.query(User.name).\
... filter(User.addresses.any(Address.email_address.like('%google%'))):  
... print name
jack

has()any()一样在应对多对一关系的情况下(注意“~“意味着”NOT”

>>> session.query(Address).\
... filter(~Address.user.has(User.name=='jack')).all()  
[]

12.4 常见的关系运算符

== = None 都是用在多对一中,而contains()用在一对多的集合中:

query.filter(Address.user == someuser)
query.filter(User.addresses.contains(someaddress))

Any()(用于集合中):

query.filter(User.addresses.any(Address.email_address == 'bar'))#also takes keyword arguments:
query.filter(User.addresses.any(email_address='bar'))

as()(用在标量?不在集合中):

query.filter(Address.user.has(name='ed'))

Query.with_parent()(所有关系都适用):

session.query(Address).with_parent(someuser,'addresses')

13 预先加载(跟性能有关)和lazy loading相对,建议直接查看文档吧

待补充。。。

5月 042015
 
 
如果PostMethod提交的是中文字符,需要加上相应的编码格式:  post.setRequestHeader("Content-Type","application/x-www-form-urlencoded;charset=utf-8");  
如果GetMethod提交的参数有中文字符,需要先转换成utf-8格式:  URLEncoder.encode("中文", "utf-8"); 
测试代码如下:
package httpclient;

import java.io.IOException;
import java.net.URLEncoder;

import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.HttpMethod;
import org.apache.commons.httpclient.NameValuePair;
import org.apache.commons.httpclient.methods.GetMethod;
import org.apache.commons.httpclient.methods.PostMethod;

public class HttpClientTest {

	public static void main(String[] args) throws Exception{
		String url = "/xx.jsp/xxxx";
		String host = "www.xxx.cn";
		String param = "city="+URLEncoder.encode("测试", "utf-8")+"&userID=";
		HttpClient httpClient = new HttpClient();
		httpClient.getHostConfiguration().setHost(host, 80, "http");

		HttpMethod method = getMethod(url, param);
		//HttpMethod method = postMethod(url);

		httpClient.executeMethod(method);

		String response = method.getResponseBodyAsString();
		//String response = new String(method.getResponseBodyAsString().getBytes("ISO-8859-1"));
		System.out.println(response);
	}

	private static HttpMethod getMethod(String url,String param) throws IOException{
		GetMethod get = new GetMethod(url+"?"+param);
		get.releaseConnection();
		return get;
	}

	private static HttpMethod postMethod(String url) throws IOException{
		PostMethod post = new PostMethod(url);
		post.setRequestHeader("Content-Type","application/x-www-form-urlencoded;charset=utf-8"); 
		NameValuePair[] param = { new NameValuePair("city","测试"),
				new NameValuePair("userID","")} ;
    	        post.setRequestBody(param);
    	        post.releaseConnection();
		return post;
	}
}

8月 072013
 

[[email protected] ~]$ redis-cli –help

redis-cli 2.4.16 

Usage: redis-cli [OPTIONS] [cmd [arg [arg …]]] 

  -h <hostname>    Server hostname (default: 127.0.0.1) 

  -p <port>        Server port (default: 6379) 

  -s <socket>      Server socket (overrides hostname and port) 

  -a <password>    Password to use when connecting to the server 

  -r <repeat>      Execute specified command N times 

  -i <interval>    When -r is used, waits <interval> seconds per command. 

                   It is possible to specify sub-second times like -i 0.1. 

  -n <db>          Database number 

  -x               Read last argument from STDIN 

  -d <delimiter>   Multi-bulk delimiter in for raw formatting (default: n) 

  –raw            Use raw formatting for replies (default when STDOUT is not a tty) 

  –latency        Enter a special mode continuously sampling latency. 

  –slave          Simulate a slave showing commands received from the master. 

  –pipe           Transfer raw Redis protocol from stdin to server. 

  –bigkeys        Sample Redis keys looking for big keys. 

  –help           Output this help and exit 

  –version        Output version and exit

–raw 显示中文,而不是"xd6xd0"

redis 10.10.100.18:6379> set aaa 中

OK

redis 10.10.100.18:6379> get aaa

如果你是用的windows cmd,还是乱码,要设置窗口的编码

chcp 65001  就是换成UTF-8代码页,在命令行标题栏上点击右键,选择"属性"->"字体",将字体修改为True Type字体"Lucida Console",然后点击确定将属性应用到当前窗口